Performance and Scalability

This project enhances the back end performance of core's CSS and JavaScript aggregation features.

- CSS and JavaScript aggregates are generated using the same lazy creation pattern as image derivative presets.

- This allows css and javascript aggregates to be built by multiple, parallel threads during cold starts. Core currently builds them inline during the page rendering process can add around 900ms to serving pages that do this.

7.x

Features (7.x)

Imageinfo Cache will generate image styles right after an image is uploaded and also on entity save. This will help with front end performance as the needed image style will already have been generated; thus the end user doesn't have to wait for the image to be generated. This can also mitigate some issues with image style generation if your CDN is configured incorrectly as the images will be generated without the request going through the CDN.

Important disclamer

While this was a nice PoC from my point of view, I never maintained this module. Please use mature solutions instead such as https://github.com/makinacorpus/drupal-gulpifier or https://www.drupal.org/project/advagg instead.

Original module summary

THIS MODULE IS NOT DRUPAL CORE: it provides some CSS and JS file handling replacement FOR core. Please stop filing issues for core bugs in here.

This module changes the Drupal core aggregation mecanism process. It greatly reduces I/O and aggregated number of files, and improves chances of client cache hit, therefore while it produces bigger aggregated files, it reduces greatly the bandwidth utilization while users browse.

This is achieved by bypassing the dynamic CSS and JS inclusion. Instead of including and aggregating only needed files on a per-page basis, it learns files being used site-wide while user browse, then is able to produce larger therefore more revelant files that aggregate all those atomic files whether or not they are being used on the page.

Over time, the number of aggregated files reduce to achieve a stable state where all site JS files are being aggregated in one file only, and all site CSS are being aggretated in only two files (libraries into one side, theme files into another, can be more if there are browser-specific files).

This module integrates Node.js with Drupal.

It provides an API that other modules can use to add realtime capabilities to Drupal, such as push notifications or chat. The module relies on a Node.js server application that maintains an open connection with the visitor's browser to enable instant communication. In order to use this module, you will need to install the Node.js application on a server.

The modular external cache invalidation framework.

The purge module facilitates cleaning external caching systems, reverse proxies and CDNs as content actually changes. This allows external caching layers to keep unchanged content cached infinitely, making content delivery more efficient, resilient and better guarded against traffic spikes.

This module is an replacement for the Cookie Cache Bypass module that is a part of the Drupal 6 Pressflow distribution.

The purpose of the module is to set a short-lived NO_CACHE cookie on form submissions so that when using a reverse-proxy (such as Varnish) you could be certain that your site visitors would get dynamic pages after form submissions.

This module performs the same function, but adds some customizations for users.

7.x & 8.x

Summary (7.x & 8.x)

This module is a time, memory and hook calls measure and profiling framework. It intensively use hooks to take ponctual measures and saves it for further consulting. It aims to be non-intrusive and lightweight as possible during runtime, however, do not activate it on production sites.

The Barracuda (part of BOA) project has moved to Github!

* Use our Github project for contributing code, or reporting bugs, or requesting features.
* There is also a Gitter community channel.

New releases announcements are posted on Twitter

A Drupal integration layer for Node.js developers

This is a module that allows the integration of a Drupal installation with a custom Node.js app. It provides an API so
that Node.js developers can directly read and write in Drupal's repository, using constructs like node, user,
permission, etc., without having to worry about the underlying implementation and setup of the Drupal installation.