Using mod_pagespeed in some infrastructures for supporting high-traffic sites 
has the potential to dramatically slow down site access.

Consider the following situation:

Initially: 

* The site is served by a set of web-servers behind a load-balancer that only 
serve dynamic html pages.  The servers do not store any JS, CSS, or image 
files.  The pages are served with all JS, CSS and image URLs referencing a CDN 
domain who's origin stores those resources (and which isn't the site end-point 
and doesn't run Apache).

* The servers can support the traffic for only the HTML requests, but would not 
be able to handle the added traffic if the same clients also make requests for 
JS/CS/Images.

After mod_pagespeed implemented:

* All the CS/JS/Image resources are made available to the web-servers as 
subresources (local filesystem files) and mod_pagespeed was enabled.  The 
ModPagespeedMapRewriteDomain directive is used to have rewritten resources 
reference the CDN domain.  The ModPagespeedLoadFromFile directive is used so 
that all JS/CS/Image files can be fetched by mod_pagespeed directly from the 
local filesystems (which are mirrored, but not shared - i.e. cache files 
generated by mod_pagespeed are not propagated across servers)

* The CDN is reconfigured to make 'origin pull' requests to the web-servers 

Result:

* Whereas previously, no JS/CSS/Image requests at all were made to the 
web-servers, now they experience a significant volume of traffic accessing the 
JS/CS/Image files and they are unable to handle the load and consequently 
respond slowly and frequently return 500 HTTP responses causing degraded client 
experience.


The reason for this is that, despite the fact that the JS/CS/Image resources 
are on the web-server local filesystems and are not changed (neither content 
nor fs file modification timestamps change), mod_pagespeed often serves html 
pages in which the unmodified resources are referenced directly using the site 
domain.  Since they are not always rewritten, the ModPagespeedMapRewriteDomain 
is not applied to have the URLs referenced via the CDN (which will have cached 
copies of the resources with far future expiry times and max-ages).

(As an aside, I can't determine any pattern to the rewrite behaviour of 
mod_pagespeed.  In testing, if I access the same site page repeatedly at 1min 
intervals - which ideally would just return the same exact response each time - 
there are different combinations of rewritten and non-rewritten CSS files in 
each response and sometimes CSS files that were combined in a previous response 
are separate in a subsequent one.  There is no pattern - like a 5min period, 
for example - sometimes it returns the same response for minutes at a time 
(from <5 to >5) and then suddenly won't give the same response twice for 
several minutes).


To ensure that no JS/CS/Image resource is ever requested by client browsers 
directly to the site domain, I'd like to propose a 
ModPagespeedMapRewriteFailedDomain directive which works like the 
ModPagespeedMapRewriteDomain directive but the specified domain is used when an 
attempt to rewrite a resource fails.

That way, the configuration can ensure that both rewritten and not-rewritten 
resources will always be requested by clients via the CDN domain, which will 
only request non-rewritten resources from the origin site server rarely due to 
the long expires/max-age headers used (along with query-string version 
parameters).

Thank you!