Move tracking code to Google Tag Manager

Visitors must give positive consent before their data is used. If you are tracking customer visits with third party tools such as Google Analytics, or customer service modules the user needs to “opt in” and give positive consent to permit you to use his data. By using Google Tag Manager you can load all your custom html and javascript tracking code after the user provides consent. Google Tag Manager applies your third party tacking code to all pages making it easier to implement changes.

Add a cookie consent toolbar

The GDPR wants you to clearly state what personal data if any you are storing or sharing with third parties. You need to add a cookie consent toolbar to your Magento site that clearly states how and why you use cookies, which third party tracking tools you use and how you share visitor data with third parties. Visitors must give positive consent to this policy – it is no longer acceptable to say that consent is implied by using the website, users must actively provide consent and your backend logic must implement this. Give visitors as much information as possible and link the cookie consent toolbar to your Data Protection (Privacy) Policy.

Allow individuals to remove or anonymise data

You need to be able to provide assurance that admin staff or customers can remove personal data stored in your Magento store on request.

Allow individuals to opt out from subscriptions

Make sure your opt-out (and opt-in) to newsletter subscriptions is working.

Perform Security Testing

Use the Magento Security scan or Mage Report to provide assurance that your Magento installation is up to date and patched against known security vulnerabilities.

Update your Data Protection (Privacy) Policy

Make sure your Data Protection Policy is up to date and available from every page of your Magento site.

Data Access

Individuals have the right to ask you of all their personal data and this needs to be a full copy of all data held in Magento. Make sure you are able to fulfill such a request, the GDPR states that this information should be made a available, without charge, within 30 days of the request.

Create a Compliance Document

You need to be able to demonstrate a diligent and earnest effort to comply with the GDPR. Create a compliance document that shows how you are meeting the GDPR requirements, the document should include

• A compliance audit
  • List the steps you have taken to comply with the GDPR
• Information audit
  • Audit your systems and clearly state where personal data is stored
    • is it internet facing?
    • is it shared with third parties?
    • how is it secured?
    • Where is it physically stored, servers, pc’s etc.
• Data Protection Policy
  • Include your policy documents

Magento GDPR Compliance Module

A quick Google for GDPR modules for Magento 1.x and 2.x show there are a few solutions available and most are not free. Two free modules are available

Magento 1 https://marketplace.magento.com/zero1-zero1-gdpr.html

Magento 2 https://github.com/AdFabConnect/magento2gdpr

I don’t yet have a live Magento 2 store so have not tested the Magento 2 module. I installed the Zero1 module and found it to contain a couple of bugs which made it unuseable, it appears to be bait to encourage you to purchase the commercial version. The module is fairly simple providing you with a frontend Cookie Consent toolbar, a frontend customer account deletion/anonymisation button and a backend method for anonymising customer data. I took this code and enhanced it with an existing cookie toolbar I had previously developed and the module is free to test and use at https://github.com/gaiterjones/magento1-gdpr

Install the module with modman using modman clone https://github.com/gaiterjones/magento1-gdpr

You will see a new menu item called GDPR in the Configuration -> Customers section.

Adding your Google Tag Manager ID enables the Google Tag Manager code which will insert any tags you have configured into your Magento site.

Enabling the customer account deletion and anonymisation will provide you with two new admin buttons when you view customer information

This enables admin staff to delete and anonymise customer and order data and send a confirmation email. In debug mode both these buttons can be tested for functionality. A similar button is activated in the frontend Customer Account section allowing customers to close their account and anonymise their data. You will be notified by email when a customer closes their account.

Debug mode lets you test the module without actually deleting anything, specifically the confirmation emails and notices sent by the module.

You change the look of the Cooke Policy consent bar skin choosing between light or dark skins and you can customise the consent bar text further as you wish.

You can see the consent bar working at http://magento1.gaiterjones.com

Seek advice

Compliance with these new regulations is important, if you are unsure where to begin with GDPR compliance seek professional advice!

The information presented here is a summary of my own personal findings and thoughts on how to improve Magento 1 GDPR compliance and no guarantee whatsoever is provided that the information presented here will ensure GDPR compliance! Use the Magento module at your own risk – be sure to test it first on your development site.

Magento is a very data and database intensive application. By enabling the Magento system cache you will instantly see an improvement in response times as Magento starts to cache database queries and system data. The default cache storage code uses the file system, i.e. Magento saves cache data to disk. Whilst this will certainly improve Magento responsiveness there are other cache storage options available that are much faster and there are additional types of data we can also cache to improve the overall responsiveness and speed of a Magento CE application.

memcache and redis

For most computer systems the fastest data storage medium is the physical memory, using memory as cache storage results in very quick data access times and Magento can get it’s data much quicker. For CE users with a small to medium sized shop there are two free popular open source memory caching systems, Memcache and Redis. I have used Memcache in many different applications for fast access to relatively non volatile (i.e. cached) data objects.

In a PHP environment memcache is easy to install and easy to use. It also works out of the box with Magento simply by configuring memcache as a storage option within the cache settings of the magento local.xml file. Redis was relatively new to me and is a slightly more advanced key-value cache and object store, it can be thought of as a simple memory resident database.

There are a lot of discussions as to the pros and cons of memcache vs redis and for a complete Magento CE cache solution I would recommend using redis as it provides the best caching solution for Magento CE system, session and full page caches.

what to cache

When you go to the Magento -> System -> Cache Management screen as shown above you will see the available cache storage management options for your Magento installation. Magento has a default built in cache management system that when enabled caches system data such as configuration, layouts, blocks, translations etc.

We can also use redis to create a fast Magento CE caching system for session and full page (fpc) data too.

This blog will look at how to install and configure a system, session and full page cache management solution for Magento CE v1.7.0.0 or greater using redis on Ubuntu 14.04 LTS.

Install redis for Magento CE on Ubuntu 14.04

Installing redis on Ubuntu is dead easy, simply use the following two apt commands to install the server and php5 code. At the time of writing this will install redis v2.8.4.

apt-get install redis-server
apt-get install php5-redis

The redis server will install and start an instance with it’s default configuration listening on TCP port 6379. Check the server is running by typing redis-cli ping at the command prompt, you should get a satisfying PONG back.

We want to enable three Magento cache types : system, session and fpc (full page cache), whilst all three cache types could use one redis storage instance there are some issues where it is safer to give each cache type it’s own redis storage instance. This also allows us to specifically configure redis options for each cache type, for example we can configure volatile session data to be redis persistent.

Ideally we want to configure three redis instances per Magento CE installation or shop :

1. system – redis port 6379
2. session – redis port 6380
3. fpc – redis port 6381

Configure multiple redis instances for Magento on Ubuntu 14.04

To configure multiple redis instances that will start at system startup we need to replace the default redis-server init script in /etc/init.d with the script below courtesy of robofirm.

Stop the redis server, change into the /etc/init.d folder and make a backup copy of the redis-server init script, then empty the original script, edit it and paste in the multi instance script from above.

service redis-server stop
cd /etc/init.d
cp redis-server redis-server.old
> redis-server
nano redis-server

The redis config files are saved in /etc/redis. We want to create a config file for each redis server cache storage instance in a new folder called servers.

cd /etc/redis
mkdir servers
cp redis.conf ./servers/server1.conf
cp redis.conf ./servers/server2.conf
cp redis.conf ./servers/server3.conf

Now we have three configuration files for our three caches :

1. server1.conf – system (redis port 6379)
2. server2.conf – session (redis port 6380)
3. server3.conf – fpc (redis port 6381)

We need to edit each configuration file and configure the redis settings for each cache. There is a lot of configuration information in the default redis.conf file most of it relating to options that are commented out and not required. The most important settings are the TCP port numbers used for each instance, the process id, log file name and persistence data.

Redis can be configured to automatically save (or persist) cached data to disk, this is really useful for volatile cache data, i.e. data you do not want to lose. Essentially redis saves a dump of the cache data regularly to disk (in /var/lib/redis) so that if the redis instance crashes or the server is restarted the cached data is not lost. This is great for cached Magento session data, we want this data in fast cache storage but we do not want to lose the data unlike system and full page cache data where we don’t really care if the data is lost – it will just be cached again.

Below are three example config files for the three cache types, you can configure your instances with these settings, or use the info to customise the default config files created in the /servers folder. You must at least make the tcp port numbers and pids unique.

Now we can start the three redis server instances with

service redis-server start

Install and configure redis Magento backend system cache Cm_Cache_Backend_Redis

Support for redis as a Magento system cache started life as a Magento community project. Meet Colin Mollenhour who appears to be the main genius behind the modules developed to use redis as a Magento/Zend cache storage system (as well as the mighty modman). Such was the popularity of Colin’s backend system cache module it was included as part of the Magento core distribution as of Magento CE version 1.8.0.0. You will find Mage_Cache_Backend_Redis declared in lib/Mage/Cache/Backend/Redis.php which since version 1.8.0.0 extends Colin’s Cm_Cache_Backend_Redis in lib/Cm/Cache/Backend/Redis.

You can find the source code to the Cm_Cache_Backend_Redis backend system cache redis module as well as support information here. I asked Colin what his recommendation was for updating Cm_Cache_Backend_Redis and his answer was  ‘ I definitely recommend the latest master from github for all versions of Magento.’ So you need to be running Magento CE vesion 1.7.0.0 or newer and should install the latest vesion of Cm_Cache_Backend_Redis from the github.

Install Cm_Cache_Backend_Redis with modman

You can install Cm_Cache_Backend_Redis by simply cloning/downloading the git source and then copying the files into your Magento root folder. However a much better way of installing this code (and all community modules for Magento) is to use modman, the module manager also created by Colin Mollenhour. I was a bit apprehensive about modman at first as I didn’t fully understand how it was working and did not want to lose control over where magento module files were installed but once you are familiar with it, it really does make module installation and management a hell of a lot easier.

Install modman

If you have never used modman before install it from the command line, it is a script file that will require execution permissions.

bash < <(curl -s -L https://raw.github.com/colinmollenhour/modman/master/modman-installer)
Done. Modman installed in /root/bin/modman
mv /root/bin/modman /home/myapps/
export PATH=/home/myapps:$PATH

Modman lets you store all your Magento module code in one location independant of your actual Magento installation. This is useful as it lets you manage and control your module code seperately from Magentos core code and folder structure, this makes installing, testing, updating and removing modules much easier. Modman works by creating symlinks within the Magento application to the real module files in a .modman folder. Before using modman make sure you enable “Allow Symlinks” (found under System > Configuration > Advanced > Developer -> Template Settings).

Once you have installed the modman script you need to determine where modman will be initialised and your modman folder will be installed. I recommend you initialise modman in a folder outwith your Magento installation. For example if Magento is installed in /home/www/magento initialise modman in /home/www then create a .basedir file to tell modman where the Magento application is installed relative to the .modman folder i.e. magento

cd /home/www
modman init
Initialized Module Manager at /home/www
cd .modman
echo magento > .basedir
cd ../magento

Now you have modman installed and initialised and can install any Magento module that supports modman.

To install Cm_Cache_Backend_Redis make sure you are in your Magento application folder and enter

modman clone git://github.com/colinmollenhour/Cm_Cache_Backend_Redis.git

modman installs Cm_Cache_Backend_Redis and we can now configure the system cache in Magento.

Configure Magento redis system cache

To configure Magento to use the Cm_Cache_Backend_Redis module to cache system data we need to edit the Magento /app/etc/local.xml file and within the global tags add backend system cache redis configuration as shown below, note Cm_Cache_Backend_Redis is defined as the backend cache module. Also note the port number we are using for the backend system cache is the port number of our first redis instance 6379 and the compression method being uses is gzip.

<cache>
	<backend>Cm_Cache_Backend_Redis</backend>
		 <backend_options>
			<server>127.0.0.1</server>
			<port>6379</port>
			<persistent></persistent>
			<database>0</database>
			<password></password>
			<force_standalone>0</force_standalone>
			<connect_retries>1</connect_retries>
			<read_timeout>10</read_timeout>
			<automatic_cleaning_factor>0</automatic_cleaning_factor>
			<compress_data>1</compress_data>
			<compress_tags>1</compress_tags>
			<compress_threshold>20480</compress_threshold>
			<compression_lib>gzip</compression_lib>
			<use_lua>0</use_lua>
		 </backend_options>
  </cache>

You will notice in the /app/etc folder a local.xml.additional file here you will find other configuration examples including the redis cache config above. Now go to System -> Cache Management in Magento admin and enable/refresh the cache to enable the new configuration. Magento is now using redis server instance 1 (db 0) on tcp port 6379 to cache backend Magento system data.

Monitor Magento redis system cache

We want to be sure that everything is working and Magento is actually using redis in the way we want it to. There are a few ways to monitor redis and confirm our configuration is working. The first is via the command line. You can monitor a specific redis instance by telnetting to the redis port on locahost and issuing the MONITOR command :

telnet localhost 6379
Trying 127.0.0.1...
Connected to localhost.localdomain.
Escape character is '^]'.
MONITOR
+OK
+1434702244.302408 [0 127.0.0.1:50415] "SELECT" "0"
+1434702244.303202 [0 127.0.0.1:50415] "HGET" "zc:k:cc4_CORE_CACHE_OPTIONS" "d"
+1434702244.303360 [0 127.0.0.1:50415] "HGET" "zc:k:cc4_CONFIG_GLOBAL_LOCK" "d"
+1434702244.303652 [0 127.0.0.1:50415] "HGET" "zc:k:cc4_CONFIG_GLOBAL" "d"
+1434702244.328254 [0 127.0.0.1:50415] "HGET" "zc:k:cc4_APP_4E4ABDD8DC00C3DACB3C1597944A3B6C" "d"
+1434702244.328821 [0 127.0.0.1:50415] "HGET" "zc:k:cc4_STORE_ADMIN_CONFIG_CACHE" "d"
+1434702244.329252 [0 127.0.0.1:50415] "HGET" "zc:k:cc4_APP_B1FB6E8F13287C01E5C05063633DDA4C" "d"
+1434702244.329791 [0 127.0.0.1:50415] "HGET" "zc:k:cc4_APP_E4D52B98688947405EDE639E947EE03D" "d"
+1434702244.330144 [0 127.0.0.1:50415] "HGET" "zc:k:cc4_STORE_DE_CONFIG_CACHE" "d"
+1434702244.330371 [0 127.0.0.1:50415] "HGET" "zc:k:cc4_STORE_EN_CONFIG_CACHE" "d"
+1434702244.332765 [0 127.0.0.1:50415] "HGET" "zc:k:cc4_CONFIG_GLOBAL_STORES_DE" "d"
QUIT
+OK
Connection closed by foreign host.

Here we are connecting to the system cache redis instance on port 6379 and if you browse your Magento site you should see redis cache activity as Magento saves or gets data from the cache. To monitor all redis server activity use redis-cli monitor from the command line. Note that the monitor command consumes a lot of redis resources so don’t leave it running!

There are two other graphical administration tools we can use to monitor redis activity check out how to install these later in the blog.

Install and configure redis Magento session cache Cm_RedisSession

Cm_RedisSession is another module from Colin Mollenhour that enables Magento to use redis as a cache storage system for Magento session data. By default Magento saves session data to the file system in the Magento var/session folder. Each session file is about 4Kb in size and over time the var/session folder can grow quite large if not managed. The second option for session storage in Magento is to use the Magento MySQL database. I have always avoided doing this as I don’t think session data belongs in the Magento database.

Cm_RedisSession rewrites the Magento db session save code to use redis instead of the database.

Install Cm_RedisSession with modman

Again, as with Cm_Cache_Backend_Redis if you are running Magento version 1.8.0.0 or greater Cm_RedisSession is already installed but you should upgrade it to the latest version.

In your Magento application folder install Cm_RedisSession with modman :

modman clone git://github.com/colinmollenhour/Cm_RedisSession.git

Configure Magento redis session cache

Again in /app/etc/local.xml.additional you will see a configuration example for the redis session cache, note that the configuration example from Colin is more complete and that is the one I am using here. Edit your local.xml file and add the configuration below between the global tags. Note that we specify our second redis instance on port 6380 as the session cache, also note Colin’s module uses the session_save db value normally used to store sessions in MySQL. Cm_RedisSession rewrites this code to use redis, using the db value here also means Magento will fallback (hopefully) to using MySQL to store session data should redis fail.

        <session_save>db</session_save>
        <redis_session>                       <!-- All options seen here are the defaults -->
            <host>127.0.0.1</host>            <!-- Specify an absolute path if using a unix socket -->
            <port>6380</port>
            <password></password>             <!-- Specify if your Redis server requires authentication -->
            <timeout>2.5</timeout>            <!-- This is the Redis connection timeout, not the locking timeout -->
            <persistent></persistent>         <!-- Specify unique string to enable persistent connections. E.g.: sess-db0; bugs with phpredis and php-fpm are known: https://github.com/nicolasff/phpredis/issues/70 -->
            <db>0</db>                        <!-- Redis database number; protection from accidental loss is improved by using a unique DB number for sessions -->
            <compression_threshold>2048</compression_threshold>  <!-- Set to 0 to disable compression (recommended when suhosin.session.encrypt=on); known bug with strings over 64k: https://github.com/colinmollenhour/Cm_Cache_Backend_Redis/issues/18 -->
            <compression_lib>gzip</compression_lib>              <!-- gzip, lzf, lz4 or snappy -->
            <log_level>1</log_level>               <!-- 0 (emergency: system is unusable), 4 (warning; additional information, recommended), 5 (notice: normal but significant condition), 6 (info: informational messages), 7 (debug: the most information for development/testing) -->
            <max_concurrency>6</max_concurrency>                 <!-- maximum number of processes that can wait for a lock on one session; for large production clusters, set this to at least 10% of the number of PHP processes -->
            <break_after_frontend>5</break_after_frontend>       <!-- seconds to wait for a session lock in the frontend; not as critical as admin -->
            <break_after_adminhtml>30</break_after_adminhtml>
            <first_lifetime>600</first_lifetime>                 <!-- Lifetime of session for non-bots on the first write. 0 to disable -->
            <bot_first_lifetime>60</bot_first_lifetime>          <!-- Lifetime of session for bots on the first write. 0 to disable -->
            <bot_lifetime>7200</bot_lifetime>                    <!-- Lifetime of session for bots on subsequent writes. 0 to disable -->
            <disable_locking>0</disable_locking>                 <!-- Disable session locking entirely. -->
            <min_lifetime>60</min_lifetime>                      <!-- Set the minimum session lifetime -->
            <max_lifetime>2592000</max_lifetime>                 <!-- Set the maximum session lifetime -->
        </redis_session>

Refresh your Magento configuration to enable the Magento redis session cache.

Remember that when you change your session cache your existing session data will not be automatically imported. Depending on how important retaining existing session data is you may want to import your session data from the file system or database into redis. This will then maintain all existing session data, i.e. logged in customers will remain logged in, and customer session data will not be lost.

Colin Mollenhour has included a utility to allow you to import your session data. The following commands will put your shop into maintenance mode, to stop the creation of any new sessions, and import session data from the file system. You can find more information on this migration process here.

touch maintenance.flag   # Enter maintenance mode
sleep 2                  # Allow any running processes to complete
# This will copy sessions into redis and clear the config cache so local.xml changes will take effect
php ../.modman/Cm_RedisSession/migrateSessions.php -y
rm maintenance.flag      # All done, exit maintenance mode

If the import script returns an error it means you have not yet configured or enabled the redis session cache in local.xml.

Now that you have imported existing session data you can delete the contents of your Magento var/session folder, this folder should now stay empty.

Monitor Magento redis session cache

Again we can confirm the redis session cache is working by monitoring the session cache instance on TCP port 6380. Browse to your Magento site in an incognito browser session to force Magento to create new session data, you will see the session data appear in the monitor window.

telnet localhost 6380
Trying 127.0.0.1...
Connected to localhost.localdomain.
Escape character is '^]'.
MONITOR
+OK
+1434705128.835230 [0 127.0.0.1:58060] "SELECT" "0"
+1434705128.835387 [0 127.0.0.1:58060] "HINCRBY" "sess_8fdjpoeco2panshj38m7d6cd36" "lock" "1"
+1434705128.835523 [0 127.0.0.1:58060] "HMGET" "sess_8fdjpoeco2panshj38m7d6cd36" "data" "writes"
+1434705128.835889 [0 127.0.0.1:58060] "HMSET" "sess_8fdjpoeco2panshj38m7d6cd36" "pid" "vwelive|30576" "lock" "1"
+1434705128.835939 [0 127.0.0.1:58060] "EXPIRE" "sess_8fdjpoeco2panshj38m7d6cd36" "1440"
+1434705129.201090 [0 127.0.0.1:58060] "HGET" "sess_8fdjpoeco2panshj38m7d6cd36" "pid"
+1434705129.201434 [0 127.0.0.1:58060] "SELECT" "0"
+1434705129.201469 [0 127.0.0.1:58060] "HMSET" "sess_8fdjpoeco2panshj38m7d6cd36" "data" ":gz:x\x01\xedVKO\xdc0\x10\xe6\xa7D>A\xc5\xe6\x9dl\xe2\bU\x88C+Q(\x12\xb4\x1c-\x93\xcc\xb2\x86$\x0ev\xb2KK\xf7\xbfw\xecd\xd5\xe5\xd0\xaa\xc7=\xec%\x89\xc7\xf3\xf0|\xdf\x8c'\xa5T\xf0\x8b\xd3\x84\xbei\x1aF\x940\rZ\x0b\xd9\xb2\x15\xafE\xc5{\xa9\x18>9)8\x8d\x8dN\x10P\xa2\xa
QUIT
+OK
Connection closed by foreign host.

Install and configure redis Magento CE full page cache Lesti_Fpc

Lesti_Fpc is a Magento CE module developed by Gordon Lesti that enables an internal full page cache. A full page cache is included with Magento Enterprise but for CE users this is perhaps one of the best free full page cache solutions available.

If you are trying to optimising your Magento CE installation a full page cache will instantly improve page loading time and responsiveness. You will want to thoroughly test this module on your development servers to make sure it works with your particular Magento installation and frontend theme. You should read the support information from Gordon Lesti to familiarise yourself with the way the module works and can be configured.

I was not 100% comfortable with using the module and opted to modify it to only cache pages for users not logged in as I was mainly concerned about improving responsiveness for first time visitors and Google Search / Speed Index.

Like the default Magento system and session caches Lesti_Fpc will use the file system as the default cache storage system but we can also configure it to use redis. The Lesti_Fpc full page cache is one of the main reason I moved from using memcache to redis, Lesti_Fpc can use both, but only with redis can you refresh the full page cache within Magento. With memcache the only way to refresh the cache is to purge the cache storage.

Install Lesti_Fpc with modman

From your Magento root folder, use modman to install the Lesti_Fpc module.

modman clone https://github.com/GordonLesti/Lesti_Fpc.git

Refresh your Magento configuration and you will see a new cache type listed in the Magento cache storage management admin page.

To enable Lest_Fpc select the Fpc cache type and then select enable from actions and click submit. This will enable the full page cache which will start caching to the file system in var/cache/.

Configure Lesti_Fpc redis full page cache

To configure Lesti_Fpc to use redis as the cache storage system locate the fpc.xml.sample symlink in app/etc/. Rename the symlink to fpc.xml and open the file for editing. You will see an example redis cache configuration commented out, uncomment the configuration and edit the port settings to match the port configured on our redis instance 3 for full page cache – 6381. Note how Lest_Fpc also uses Cm_Cache_Backend_Redis to cache data to redis. Neat huh?

            <!--backend>Cm_Cache_Backend_Redis</backend>
            <backend_options>
                <server>127.0.0.1</server>
                <port>6381</port>
                <persistent>cache-fpc</persistent>
                <database>1</database>
                <password></password>
                <force_standalone>1</force_standalone>
                <connect_retries>1</connect_retries>
                	<lifetimelimit>86400</lifetimelimit>
                <read_timeout>10</read_timeout>
                <compress_data>1</compress_data>
                <compress_tags>1</compress_tags>
                <compress_data>gzip</compress_data>
            </backend_options-->

Refresh the Magento configuration cache to enable the redis cache for Lest_Fpc full page cache data.

Monitor Lesti_Fpc full page cache

Again we can confirm that Lest_Fpc is using redis by monitoring our redis instance on port 6381.

telnet localhost 6381
Trying 127.0.0.1...
Connected to localhost.localdomain.
Escape character is '^]'.
MONITOR
+OK
+1434708527.473899 [0 127.0.0.1:37524] "select" "0"
+1434708528.667508 [0 127.0.0.1:37538] "select" "0"
+1434708528.728683 [0 127.0.0.1:37538] "hget" "zc:k:cc4_487CA86953D34994D28E9FEA5DCAD22EF836ECD4_PAGE" "d"
+1434708535.892402 [0 127.0.0.1:37508] "select" "0"
+1434708542.685102 [0 127.0.0.1:37478] "select" "0"
+1434708542.772018 [0 127.0.0.1:37478] "hget" "zc:k:cc4_E8F535AA519A6B32EFBB322BAFB4BA86704430AB_PAGE" "d"
+1434708543.253530 [0 127.0.0.1:37495] "select" "0"
+1434708546.151371 [0 127.0.0.1:37562] "select" "0"
+1434708546.304141 [0 127.0.0.1:37562] "hget" "zc:k:cc4_3FA4328F459A7D31B2D5B7BD4C4374494AFF146E_PAGE" "d"
QUIT
+OK
Connection closed by foreign host.

You can now also delete the contents of your Magento var/cache/ folder, Magento is no longer caching data to the file system, and when all the caching modules are working correctly this folder will stay empty.

Congratulations you now have a fully cached Magento system using a fast input/output redis memory cache.

Monitoring redis

There are two admin tools well worth installing to help you monitor redis,

Steve Robbins has developed a Magento Redis Manager module that allows you to monitor your redis confguration via a Magento admin page.

Install Magento Redis Manager

Install the Magento Redis Manager module from your Magento root folder with modman.

modman clone https://github.com/steverobbins/Magento-Redismanager.git

Refresh your Magento configuration cache, log out of admin and back in to view the Magento Redis Manager admin page under System -> Redis Management.

Here we can clearly see our three redis cache instances and how they are being used by Magento for the System (cache), Fpc and Session cache. Here you can also manually flush individual redis caches if required. You can also completely flush the cache storage from the cache management page.

Another redis administration graphical tool that is very useful is Erik Dubbelboers phpRedisAdmin. This is a php script that lets you monitor redis via your browser.

Install phpRedisAdmin

You can install phpRedisAdmin with composer, see the github page for more information.

You need to configure phpRedisAdmin with the names and port numbers of your configured redis instances, then you will see the three instances listed in phpRedisAdmin. phpRedisAdmin also lets you browse the redis data for each cache instance. Note that the last save values above show that the system and fpc caches are not being persisted, or dumped to disk by redis, the volatile session data however is persisted, and regularly saved to disk just as we configured it to.

Conclusions

Thanks to the developers of the Magento CE caching modules and redis cache storage system we have a pretty good method of optimising and improving Magento responsiveness with a cost effective fast caching system. Of course redis configured on a single server will have it’s limits, but for a small to medium sized ecommerce shop this solution should suffice and you should be able to implement a good caching system and experience good results from caching your Magento data.

You can see this cache system using the config from this blog running on my dev Magento 1.9.x store.

Credits

• Colin Mollenhour
  • modman
  • backend and session modules
• Gordon Lesti
  • Lesti full page cache
• Steve Robbins
  • Magento Redis Manager
• Erik Dubbelboer
  • PHP Redis Admin

Google Page Speed Insights

The Google Page Speed insights tool gives you a good idea as to how your Magento site is performing according to Google’s page speed analysis rules. It will rate your page speed for both Desktop and Mobile devices on a scale between 1 and 100, the higher the rating the better. Apart from the general response speed of your server it concentrates on some basic optimisation rules including compression and browser caching.

Google will provide you with some guidance to help you improve your page speed analysis results. The main speed issues all Magento stores are going to suffer from will, despite all your optimisation attempts, probably always eventually come back to your server hardware resources and configuration. The mean time to the first byte delivery for a Magento store will be very dependant on server, database and network resources that may be out of your control (or budget) especially as Magento is already a pretty data intensive beast.

Here are 5 ways to improve your Magento Google Page Speed insight results.

1. Buy a new server / enable full page caching

Ok, so a new server is probably not going to be an option, but remember if your server is not up to spec for your Magento installation no amount of optimising is going to make your server faster. Full page caching might be an option to help improve server response times.

2. Enable Apache Compression

Assuming you are using Apache, make sure compression and the mod_deflate module is enabled. mod_deflate is an Apache module which “provides the DEFLATE output filter that allows output from your server to be compressed before being sent to the client over the network.” (from its web). You need to make sure the module is enabled before you try to configure compression. To do this with Ubuntu for example simply enter

a2enmod deflate
service apache2 restart

Now take a look at the default Magento .htaccess file in the root of your Magento folder,  Make sure the section with the deflate compression rules is not commented to enable the default compression rules.

############################################
## DEFLATE COMPRESSION
    AddOutputFilterByType DEFLATE text/html text/plain text/xml text/css text/javascript
    AddOutputFilterByType DEFLATE application/xml application/xhtml+xml application/rss+xml
    AddOutputFilterByType DEFLATE application/javascript application/x-javascript
    #AddOutputFilterByType DEFLATE application/x-httpd-php

    BrowserMatch ^Mozilla/4 gzip-only-text/html
    BrowserMatch ^Mozilla/4\.0[678] no-gzip
    BrowserMatch \bMSI[E] !no-gzip !gzip-only-text/html

    SetEnvIfNoCase Request_URI \.(?:gif|jpe?g|png)$ no-gzip dont-vary
    SetEnvIfNoCase Request_URI \.(?:exe|t?gz|zip|bz2|sit|rar)$ no-gzip dont-vary
    SetEnvIfNoCase Request_URI \.(?:pdf|doc)$ no-gzip dont-vary
    SetEnvIfNoCase Request_URI \.(?:avi|mov|mp3|mp4|rm)$ no-gzip dont-vary

These are the default rules, if you google this subject you will also find suggestions to improve on / customise these rules. Some will also argue that you should move the .htaccess rules to your apache site .conf file.

3. Enable Browser Cache Rules

Similar to taking advantage of Apaches compression features, you need to also make sure you are telling visitors what data their browsers can and cannot cache, and for how long. Client side caching rules obviously help considerably to reduce the time required by the browser to fetch data.

The Apache module is called mod_expires. Enable this with

a2enmod expires
service apache2 restart

Again look at the default Magento .htaccess rules and make sure the mod_expires section is not commented out.

############################################
## Add default Expires header
## http://developer.yahoo.com/performance/rules.html#expires

	ExpiresActive On
	ExpiresDefault "access plus 1 year"

4. Optimise images

The first thing you will see when Google analyses your product pages are suggestions to improve image optimisation. A good Magento store will have a lot of images, and Magento makes a good job of resizing and caching product images for various frontend views.

There are two really good lossless image optimisation tools available that can optimise all your images in seconds with just one command line: jpegoptim and pngcrush.

These are free utilities that should be available for your flavour of Unix. In ubuntu you can install them with

apt-get install jpegoptim
apt-get install pngcrush

First take a backup of your Magento installation, or at least your /media/catalog/product and category folders.

To optimise every single product image open a terminal session and change to your magento media/catalog/product folder. Now execute the following command line

find . -type d -exec  sh -c "/usr/bin/jpegoptim --strip-all -t {}/*.jpg" \; | perl -e '@a=<>; $a=join("", @a); @b = $a =~ /%\s+\((\d+)k\)/g; foreach my $n (@b) {$sum = $sum + $n}; print "Total saved ${sum}k\n"' 

This will optimise all jpg files in the current folder and all subfolders. The original file will be overwritten and a summary of the compression savings shown at the end. Be sure to reset the permissions of all the image files after running the optimisation as they will have all been reset which can lead to them not being accessible by Apache.

If you have png files you want to optimise the corresponding pngcrush command is

for png in `find $1 -iname "*.png"`; do pngcrush -ow "$png"; done

Before you jump in and optimise all your images make sure you have a backup, and I would also do a test optimisation on your production server. Replacing thousands of broken product images is really no fun at all.

5. Minify and Optimise JS, CSS and HTML

The best way to minify and optimise your javascript and style sheet files for Google page insights is to enable the Magento js and css combination feature in admin. I would also recommend installing the Fooman Speedster Advanced module. I noticed the new RWD theme in Magento 1.9 now supports SASS, this will no doubt help to improve CSS optimisation in the future, if your theme doesn’t support SCSS then have a look at manually optimising the CSS yourself using online tools. The same goes for javascript, make sure any plugins you install are using minified js files, or try to minify the source yourself using online tools.

I am currently testing a module that uses the well known minify code to minify Magento html output.

Each of these steps will help to improve the page speed insight score, html minification alone increases the rank by 1. When you add all these small improvements together your page speed rank will increase by 5 to 10 points which may well be enough to get you in to the green ranking of 85 and above.

This Magento module helps to get more Magento customer product feedback by giving customers the opportunity and incentives to complete reviews and ratings for products they have recently purchased.

HOW IT WORKS

The code in the module is called at checkout caching customer information and products ordered. The module then uses the Magento scheduling system to execute code that regularly checks the cached files to create a customised customer feedback email containing direct links to the review pages of the products the customer has ordered.

When configurable parameters, such as order status, or elapsed time since the order was placed are met the email is sent to the customer and the order status updated.

The customer feedback email allows you to directly follow up every customer order and offer incentives to the customer to complete product reviews and ratings. An example email is shown below.

Tested with Magento CE 1.3-1.9.x

GIT – https://github.com/gaiterjones/magento-GetCustomerFeedback note – the latest code will always be available at the git hub for download.

Place an order in my development store to test the customer feedback email yourself.

Updates

This module was originally coded in 2013. I updated it in 2017 with some bug fixes, better translation options and a new responsive email template.INSTALLATION

Prerequisites : PHP5.4+, Working Magento scheduling system, Magento CE 1.x

To install this module:

Modman

modman clone https://github.com/gaiterjones/magento-GetCustomerFeedback.git

Manual

1. Unzip the module and copy the contents of the modules app folder to the app folder of your Magento store installation.

2. Ensure that the module /cache folder has write permission set to allow the WWW user group write access. The module caches customer and product information in this folder.

3. Refresh the Magento Store cache

4. Logout and login back into the admin backend, goto System – Configuration and locate the configuration settings under My Extensions – Get Customer Feedback.

CONFIGURATION

Email body content:

Enter the text that will form the main body of the customer email here, this text appears before the product information. You may use HTML.

For example for the offer shown in the example above I used the following HTML, remember you should replace special characters with html entities.:

<p align="center"><img src="/images/articles/comp_win50.jpg" width="650" height="130" align="middle" /></p>
<p align="left">Thankyou for your recent order, we hope you are very happy with your products. We value your opinion so simply tell us what you think about your purchases and you could win £50 to spend with us.</p>

Email footer content:

Enter the text that will form the footer of the customer email here, this text appears below the product information. You may use HTML.

Email subject:

Enter a custom subject for the feedback email, if left blank subject is “STORENAME : Your Order # ORDERNUMBER”.

Leave feedback icon URL:

To specify your own Get Feedback icon image in the customer feedback email enter the image URL here. If no image url is specified the text “Leave Feedback” will be used.

Send feedback request email :

Specify when the email should be sent, immediately after the order completion or after a specific period of time to allow the customer time to receive the products and form an opinion. When order status check is set to YES, email will be sent X days after order status is set to complete.

Check order status: YES/NO

To only send customer feedback emails when the order status is “Complete” set this field to YES.

Test mode enabled: YES/NO

In test mode customer feedback emails are sent to the general email address of your store and not to the customer. When you are happy that the emails are formatted correctly set this option to NO and emails will be sent to the customer. Test mode is enabled by default.

To test your email and cron settings rename the test email file in the cache folder to GetCustomerFeedback.emailtest

The module will now send a test email to the general store address every time the cron scheduler runs. Delete or rename this file to stop the test emails.

Use PHP email

Send customer feedback emails using the Magento email system or directly via PHP. To BCC feedback emails use PHP email mode.

To test that you are receiving emails from the module rename the file GetCustomerFeedback.emailtestOFF in the cache folder removing the word OFF from the end. The module will send you an email every time the Magento cron.php runs. Note the default cron task is set to once per hour, you can manually change this in the module config files to a shorter period for testing if required. If you receive the test email you know the module cron task is running and email is functioning. Rename the control file again to turn off the test emails.

URL Tracking tags:

Specify Google UTM tags here to track traffic generated by customer feedback emails.

Send alert emails: YES/NO

The module will send alert emails to the general email address of the store when errors are detected, enable this option during testing and disable afterwards when the module is functioning correctly.

Edit Locale Files for Translations
In the root folder of the extension is an example locale file named translation_store_id_1.txt this will be used to translate phrases used by the extension that cannot be set in admin. If you have a multi language store a translation file should exist here for each store, i.e. if your store ID 1 is French and store ID2 is German then your translation_store_id_1.txt file should contain English to French translations and you should create a second file called translation_store_id_2.txt containing English to German translations.

ENABLE MAGENTO SCHEDULING

Magento uses a single file named cron.php to execute all its scheduled tasks –  cron.php should be executed regularly to allow configured background tasks in Magento to run and is also used by this module. For example to run cron.php every 5 minutes add the following or similar to your crontab (crontab -e):

*/5 * * * * /usr/bin/php -f  /PATH-TO-MAGENTO/cron.php

Alternatively for testing you can execute cron.php from your browser by browsing to

http://www.yourstore.com/cron.php

When you manually execute the cron job you may want to change the configured cron schedule from every hour to every minute by editing the config.xml module file otherwise your manual cron job will only run once per hour.

“Rich Snippets” are a standardised markup format used by Google to improve search results by including more specific or “rich” information relating to a web page, i.e. for product pages, price and ratings info. Google says “(we try) to present users with the most useful and informative search results. The more information a search result snippet can provide, the easier it is for users to decide whether that page is relevant to their search.”

By editing Magento product page templates we can include the Rich Snippet markup data readable by Google and improve the organic Google search results for our product pages.

There are various standards available to markup Rich Snippet Data on web pages – microdata, microformats, RDFa etc. We are going to use the microformat markup, although it does not provide as many options as other formats it does fit more easily into Magentos existing default product page design.

This Rich Snippet data will not affect the look of our product page, microformats use the class attribute in HTML tags (often <span> or <div>) to assign brief and descriptive names to entities and their properties.

We are going to use simple microformat conventions or entities to markup our product page html so that Google spiders can read Rich data from our product information such as the price, availability or review rating of a product from all our pages.

We will implement two main microformat entities, hproduct and hreview-aggregate coded within the correct sections of our product page html so that the microformat markup looks something like:

How to Markup the Default Magento Theme with Rich Snippet Information

Lets start with the hproduct microformat tag. This needs to encapsulate the main product information, including product description, image, price etc. If we look at the structure of the default magento product page we can see that the html document division with the product-essential class contains all the product information that we need, so we will add the main hproduct microformat tag here by adding hproduct to the DIV class.

hproduct

Open up your Magento theme template folder, browse to  /template/catalog/product and open up view.phtml for editing. Here you will find the html document division with the class product-essential, we simply append the new hproduct microformat class to it to add the hproduct rich snippet tag.

<div class="product-essential hproduct">

item fn

Within our microformat markup tree we now want to markup the product item, price and image sections of our Magento product html.

Still looking at view.phtml within the product-essential div we will find the product-name division. Here we will add the item fn microformat tags to markup the product name.

<div class="product-name item fn">

description

Within view.phtml we can also add the markup for the microformat description tag. An ideal place for this is the quick overview html division where we can simply append the description tag to the existing DIV class.

<div class="std description"><?php echo $_helper->productAttribute($_product, nl2br($_product->getShortDescription()), 'short_description') ?></div>

price

To markup the product price open up price.html in the same folder. This template file is responsible for returning product pricing in all areas of the Magento frontend. You will notice that all the pricing document divisions already have the class name price. We don’t need to change anything here. However if you want to include the price-range microformat tag you can include it here by adding it to the divisions with the class name price-box.

image

To tag the product image navigate to the template/catalog/product/view folder and open up media.phtml for editing. Here you will see the product image html. The product image URL is specified within an IMG tag that has the ID “image”. Simply add a new class to the IMG tag with the name photo fn.

$_img = '<img id="image" class="photo fn" src="'.$this->helper...

hreview-aggregate

The most effective data we can microformat tag is the product review and rating data which will be displayed in Google search results showing our Magento product rating information. This data is encapsulated within the hreview-aggregate tag.

Navigate to the template/review/helper folder and you will see two files responsible for rendering review and rating html. summary.phtml and summary_short.phtml. Open up summary.phtml for editing.

First we need to add the hreview-aggregate tag to the html division that contains the rating data for the product. Here you will see the DIV with the class name ratings. Append the hreview-aggregate tag to this DIV class name.

<div class="ratings hreview-aggregate">

Next you will see that Magento already uses a division with a class name of rating. This will confuse Google as the microformat name we want to use is also “rating”. However there is a method to work around this using a SPAN class. Edit the existing rating division to include the new SPAN element as show below.

            <div class="rating-box">
                <div class="rating" style="width:<?php echo $this->getRatingSummary() ?>%">
					<span class="value-title" title="<?php echo number_format($this->getRatingSummary() / 20,1); ?>"></span>
				</div>
            </div>

count

Now we markup the number of reviews the product has received with the count tag. Still within summary.phtml we add a SPAN element with the class name count to the existing code.

        <p class="rating-links">
			<a href="<?php echo $this->getReviewsUrl() ?>"><span class="count"><?php echo $this->getReviewsCount()?></span><?php echo $this->__(' Review(s)') ?></a>
            <span class="separator">|</span>
            <a href="<?php echo $this->getReviewsUrl() ?>#review-form"><?php echo $this->__('Add Your Review') ?></a>
        </p>

author

Finally lets consider the author tag. To identify the author of a blog or article, Google checks for a connection between the content page (such as an article), an author page, and a Google Profile. I am unsure if any real benefit will come from applying the author tag to your product content but for completeness one way to do it is to add the author tag to a link in the footer of your Magento pages. i.e.

<p class="author"><a rel="author" href="http://my.google.profile ">g a i t e r j o n e s</a> / <?php echo $this->__('(ver. %s)', Mage::getVersion()) ?></p>

Testing

After saving all our edited files, we can check whether our product pages are returning rich snippet data using the Google Rich Snippet Testing Tool. Goto the testing page and enter the URL of a product page from your Magento site.

The rich snippets testing tool will show you all the rich snippet data for your product page including information that comes from non microformat tags such as Meta tags or Facebook Open Graph tags. Make sure you are making best use of these tags too to ensure that Google is gleaning as much useful SEO information from your pages as possible.

 Conclusion

The main question now is will Google use our Rich Snippet data in search results and how long will it take before the Rich Snippet data shows up* – SEE UPDATE BELOW!

I am still unsure if Rich Snippet data is being used across all Google search engines and countries at this moment. The data will certainly not show up until your site is spidered, and there is no guarantee it seems that even when Google has your RIch Snippet data if they will use it or not in search results – Google says “Note that there is no guarantee that a Rich Snippet will be shown for this page on actual search results.” The FAQ page which was written in 2010 seems to suggest the use of Rich Snippet Data is limited and suggests that interested users complete an “interested in Rich Snippets” form. See the Rich Snippets Google FAQ for more infomation.

If and when Rich Snippet data is widely used by Google in search results it certainly can’t do any harm to ensure your Magento product pages are ready!

* UPDATE

I wrote this blog entry on 18th November 2011 and around the same time implemented rich snippet data in one of my webshops I just performed a Google search for one of our products today (8th December) and the rich snippet product review data is now being shown. So it took approximately three weeks for Google to pick up the new rich snippet data in our Magento products and reflect them in relevant search results.

How it Works

The code in the module is called at checkout and a random product is selected from products in  the customers cart. The information from this random “Top Seller” product is used to create a product marketing post, including a headline, short description and short Bit.ly URL to link to the product page. The built in Magento scheduling system is then used to regularly check for new marketing posts and send them to Twitter and Facebook.

To use this module you must enable the Magento scheduling system and will need a Twitter  account, and configured Twitter application, a Facebook account and configured Facebook application and a Bit.ly account, further information for setting these accounts up is detailed below.

Tested with Magento CE 1.6.1

I am looking for extension testers, download BETA version 0.26 (last updated 09-12-2011) of the extension here

Updates

If you use this extension be sure to update to the latest version.

*  0.22 – First beta release. 15.09.2011
*  0.23 – Developed Facebook integration and duplicate post control logic. 16.09.2011
* 0.24 – Improved Facebook posting, added logic to exclude posts for products in specified categories. 19.09.2011
* 0.25 – Added time range to stop being too spammy by restricting posts to specific hours of the day. 04.11.2011
* 0.26 – Fixed grouped products not being posted due to hidden child simple products of the parent group product.

Wishlist

Implement logic to control the duplication of product Tweets. Done – v0.23
Extend to other Social Media platforms, Facebook, etc. Facebook Support in v0.23
Implement hash tags for Twitter.
Add to Cart link in Facebook posts
Add option to use Short or Long description text.

Installation

Prerequisites :

Enable Magento scheduling system
Twitter Account
Twitter Application
Facebook Account
Authorised Facebook Application

Bit.ly Account (optional)

To install this extension:

1. Unzip the module and copy the contents of the modules app folder to the app folder of your Magento store installation.

2. Ensure that the module /cache and /cache/Bitly folders have write permissions set to allow the WWW user group write access. The module stores the product Tweets and caches the Bit.ly short URLs in this folder.

3. Refresh the Magento Store cache

4. Logout and login back into the admin backend, goto System – Configuration and locate the configuration settings under My Extensions – Social Media Marketing.

Configuration

1. Configure the Twitter, Facebook and Bit.ly account, authorisation and API keys. See below for further information. If you do not want to use the Bit.ly short URL service set the enable option to no.

Twitter is enabled by default, Facebook is disabled by default.

2. Define a headline prefix for the product marketing text, the default if left blank is “Top Seller:” To disable this prefix enter NONE. For Facebook you can define the text to use for the post header. Define the “uniqueness” value for posts, this value will be used to check for if a product has already been posted in the last X posts, where X is the value you define here. This will help prevent duplicate posts. You can also configure a time range so that Social Media Marketing posts will only be made during the times selected.

3. Configure Google UTM tags for traffic tracking in Google analytics.e.g. ?utm_source=SocialMediaMarketing&utm_medium=Top-Seller&utm_campaign=MyCampaig

4. Enable email alerts which will help you debug the module during testing.

5. Save the extension configuration settings and test.

Testing

Make a test order in your store to test the extension. Upon checkout completion the product marketing information will be written to the modules cache folder. At the next scheduled Magento task execution the text will be posted to Twitter (and Facebook if enabled) and the cached file deleted.

To force the Magento scheduler to run navigate to http://www.yourwebshop.com/cron.php. Check your Twitter and Facebook pages to confirm the marketing post has been submitted. Any errors that occur during this process will be emailed to the default store email address if you set email alerts enabled to YES in the configuration.

ENABLE MAGENTO SCHEDULING

Magento uses a single file named cron.php to execute all its scheduled tasks –  cron.php should be executed regularly to allow configured background tasks in Magento to run and is also used by this module to check for marketing information to post. For example to run cron.php every 5 minutes add the following or similar to your crontab (crontab -e):

*/5 * * * * /usr/bin/php -f  /PATH-TO-MAGENTO/cron.php

Alternatively for testing you can execute cron.php from your browser by browsing to

http://www.yourstore.com/cron.php

TWITTER Configuration

Folow the steps below to create a Twitter application that will be used by the module to access your Twitter account and post product marketing Tweets.

1. If you do not already have a Twitter account, create an account at http://www.tiwtter.com

2. Go to https://dev.twitter.com/ and login with your Twitter credentials.

3. Click the Create an App link.

4. Complete the first page of the application form with your application name, description and website address. A Callback URL is not required. Click the “Create your twitter app” button to continue.

5. Goto the application settings tab and ensure your application is set to Read and Write and click Update Setting to continue.

6. Click on the details tab and scroll down to the Create my access Token button, click it to create access tokens for the application. You will see the four main authentication tokens listed CONSUMER KEY, CONSUMER SECRET, ACCESS TOKEN and ACCESS TOKEN SECRET. Ensure that the access tokens have READ and WRITE access.

7. Copy each authentication token into the configuration settings of the module and click save.

If you do not want to use Bit.ly to shorten URLs in the marketing tweets you have the option of enabling t.co shortlinks in the application settings and you can disable Bit.ly in the extension settings.

You can confirm your application is enabled and has access to your Twitter account by going to account settings -> applications in Twitter.

FACEBOOK CONFIGURATION

Login to Facebook and then browse to

http://developers.facebook.com/

Create an application that will be used to post marketing information to your Facebook page, this can be a normal profile page or a Business/Fan page. When complete note the application ID and application secret.

The application must be authorised for your Facebook page to work.

To authorise the application for your page edit the following URL and paste to your browser, replaceing YOURAPIKEY and YOURPAGEID..

facebook.com/connect/prompt_permissions.php?api_key=YOURAPIKEY&v=1.0&next=http://www.facebook.com/connect/login_success.html?xxRESULTTOKENxx&display=popup&ext_perm=publish_stream&enable_profile_selector=1&profile_selector_ids=YOURPAGEID

BIT.LY CONFIGURATION

To create a Bit.ly account goto http://bit.ly and register an account. Once registered obtain your API key by clicking on Account -> Settings. Configure your bit.ly username and API key in the configuration settings of the extension and save them.Bit.ly is enabled by default in the extension, If you do not want to use bit.ly you can disable it in the configuration settings.

Simply configure a coupon as usual in Magento, set the coupon name i.e. “MYCOUPON1” but do not configure any coupon discount information. Then configure the name of the coupon in the Coupon section of the extension, and the ID of the free product, product Y. You should create a new or duplicate an existing product to create a unique product ID for your free gift.

When the customer enters the coupon code, the free product is added to the cart.

See the full extension page post for more information and to download. Thanks to Darren for the idea!

Google launched their Plus (+) range of products this week, Google + integrates existing products from Google along with some new social products into a new “social networking” service. Obviously Google want to challenge Facebook as a new social networking hub. While Facebook already have a huge user base, it is nothing compared with the number of users interacting with Google on a daily basis.

Interestingly, as Facebook attempts to assimilate the Internet into its own social networking open graph database populated with millions of people, Google , who already have the Internet indexed and cached in its huge databases now want to pull in the millions of people to create a social networking environment built around existing, new products and of course their number one business their search engine.

Enter the Plus One Button

The Google plus one button is to Google searches what the Facebook like button is to web content. Google says “The +1 button is shorthand for “this is pretty cool” or “you should check this out.””. When you or someone in your Google social circle “plus one” something by clicking the plus one button on a site, this information will be used by Google to manipulate/improve Google search results so that when you search for something you will be able to see for example if your friends have already recommended the product returned in the search. If your best buddy likes it, it must be good right? Whether its “pretty cool” or not lets wait and see, no doubt Google Plus will be THE next big thing. The plus one button is a clever way for Google to rewarding good web content and personalise search results, as (in theory) only humans will be able to “Plus One” something.

I am still getting my head around Google plus one and all of its implications but needless to say if there is a new social media marketing opportunity out there, especially one so tightly integrated with Google search then we need to take advantage of it and enable plus one buttons for our Magento products. Content with a large amount of +1s will get higher rankings in Google’s organic search results, create more visibility for your products and drive more traffic to your site. Google says “Think of the +1 button as a way for fans of your business to recommend what you offer, for all their friends and contacts to see. By helping searchers see more personal, relevant ads, we believe you’ll see more qualified traffic.”

Here is a 5 minute fix to add the plus one button to all Magento product pages.

Adding Plus One

For Magento 1.4+ stores:

We can place the Google plus one button next to our Facebook Like button with a few lines of code. Locate view.phtml in your theme, it will be located in the default/template/catalog/product folder of your theme.

<!-- Google Plus One Button BEGIN -->
<div id="google-plusone">
<script type="text/javascript" src="https://apis.google.com/js/plusone.js">
{"parsetags": "explicit"},
{"lang": "<?php echo $this->__('en-GB') ?>"}
</script>
<g:plusone size="medium" count="false" href="<?php echo trim(Mage::registry('current_product')->getProductUrl()) ?>"</g:plusone>
</div>
<script type="text/javascript">
gapi.plusone.go("google-plusone");
</script>
<!-- Google Plus One Button END -->

If you already have implemented a Facebook Like button, insert the following code below the existing code You can also position the google-plusone DIV wherever you would like the button to appear on the page with CSS.

To translate the locale code correctly add a line to your themes locale file and refresh your cache. For example for a German language store use

“en-GB”,”de”

For Magento 1.4+ make sure you have canonical URLs enabled in admin (see my Facebook Like button post for more info), we have specifed the URL in the Google API code to ensure Google uses the Magento enabled canonical URL. They say that the code will default to look for the canonical tag but better to be safe than sorry – in my tests it was not always used. The size and appearance of the button can be modified by changing the size and count options. See the Google documentation for more details.

Further Reading

http://en.wikipedia.org/wiki/Google%2B

http://googleblog.blogspot.com/2011/06/introducing-google-project-real-life.html

http://www.ibtimes.com/articles/172678/20110701/google-plus-facebook-killer-google-zynga-android-developers-facebook-losing-users-google-plus-next-b.htm

http://www.aaronpeters.nl/blog/google-plus1-button-performance-review

Google announced on the 26th of May 2011 (the day I blogged about this solution!) that the translation API used by the jQuery plugin is now deprecated and will be shut off completely in December 2011. The author of the jQuery plugin will develop it to use the Microsoft translation API. Google are shutting down the API due to “extensive abuse” and recommend using the Google Translate Element. Whether the Microsoft translation service will be as good as Google we will need to wait and see. The author of the plugin comments “… the Microsoft API provides a method for array translation (just as Google’s v2 API), which eliminates almost all bugs with this plugin, and will make it a bit faster too. The quality of the translation is not any worse I think, so there’s nothing to worry about.” If you want to implement this solution bear in mind that changes to the plugin will take place at some point and the Google API will certainly stop working in December 2011.

Automatic jQuery Translator for Magento

Having looked at integrating the Google element translation tool into Magento to provide a quick fix content translation service I wanted to improve this tool by automatically translating content based on visitor browser language without the visitor having to manually select a language on every page. Despite spending a lot of time looking at ways to manipulate the Google element translator code I couldn’t come up with a good solution until I came across the jQuery dynamic google translation plugin which integrates the Google Ajax Language API to jQuery and provides a really flexible and powerful method of dynamically translating content. Using jQuery and the jQuery translation plugin we can create an automatic language translation service for Magento that detects the visitors browser language and automatically translates every Magento page to that language when it is loaded, or alternatively does the same when a new language is manually selected from the language drop down selector. This is quite an easy solution to implement but should be thoroughly tested on your development platform as it requires some changes to existing javascript libraries as well as the addition of new jQuery libraries and plugins. I have included the new jQuery libraries and plugin files required to implement this solution in a download which you can access here. Download and extract the files, copy them to your Magento installation folder and then follow the instructions below to implement automatic jQuery Google translations in your Magento store.

jQUERY & script.aculo.us
According to this Magento blog post jQuery should have no problems working with other javascript frameworks and should “work out of the box” with Magento but doesn’t due to a conflict with an older version of scriptaculous.The Magento conflict lies with the code in effects.js which we will upgrade to the latest version (1.9.0 as of December 23, 2010).

jQuery, jQuery Translator plugin and UIBlock plugin

The other libraries required are the jQuery library which provides the jQuery framework, the jQuery Translator plugin which currently integrates with the Google API to do the translations and the UIblock plugin which I’ve used to provide a neat way of updating the user interface when translations are taking place. These are included in the download package. After copying the new libraries across to the Magento /js folder we need to update the page layout XML in Magento so that the new libraries are loaded. Locate page.xml in the layout folder of your Magento stores theme and open it for editing.

Installation

First find the XML that loads the existing scriptaculous effects.js file and modify the line that loads the effects.js library and change it to load the new upgraded version as shown below. Double click the code box and use CTRL C to copy.

 <action method="addJs"><script>scriptaculous/effects-1.9.js</script></action>

Next we need to add some new XML to tell Magento to use the new jQuery library and plugins, add the following three lines before the existing line of XML that loads the prototype library in page.xml

<action method="addJs"><script>jquery/jquery-1.2.6.noConflict.min.js</script></action>
<action method="addJs"><script>jquery/jquery.translate-1.4.7.js</script></action>
<action method="addJs"><script>jquery/jquery.blockUI.js</script></action>

Save the modified page.xml file. The dynamic translation jQuery code can be placed in the footer.phtml template file of your Magento theme so that it runs when the page is fully loaded, this file is usually located in the template/page/html folder of your theme. Locate the file, open it for editing and append the following code at the bottom:

	<?php
	/**
	 * Automatic jquery translator for Magento
	 * blog.gaiterjones.com
	 * v0.3
	 *
	 */
	?>
	<script type="text/javascript">
	//<![CDATA[
	jQuery(function($){

			var defaultLang = '<?php echo substr(Mage::app()->getLocale()->getDefaultLocale(), 0, 2) ?>';

			$('#langSelect').change(function() {
				var pathname = window.location.pathname;
				window.location = pathname + '?translateTo=' + $('#langSelect').val();
				if ($('#langSelect').val() == defaultLang) {
					$.blockUI({
					message: '<h1>Language is being reset to default...</h1>',
					timeout: 2000
					});
				}
			});

			function doTranslateTo( destLang ){
			$('body').translate(defaultLang, destLang, {
			  not: '.doTranslate',
              start:     function(){   $.blockUI({ message: '<h1>Translating, please wait...<br />(' + defaultLang + ' > ' + destLang + ')</h1>' })   },
              complete:  function(){   $.unblockUI()  },
			  error:  	 function(){   $.growlUI('Translation Error', 'An error occured during translation...');   },
			  toggle: true
			});
	}

		<?php

		$defaultLang=substr(Mage::app()->getLocale()->getDefaultLocale(), 0, 2); // default store language

		// determine browser langugage
		if (isset($_SERVER['HTTP_ACCEPT_LANGUAGE'])) {
			// get languages from server header and assign quality rating
			foreach (explode(",", strtolower($_SERVER['HTTP_ACCEPT_LANGUAGE'])) as $accept) {
				if (preg_match("!([a-z-]+)(;q=([0-9.]+))?!", trim($accept), $found)) {
					$langs[] = $found[1];
					$quality[] = (isset($found[3]) ? (float) $found[3] : 1.0);
				}
			}
			// Order the codes by quality
			array_multisort($quality, SORT_NUMERIC, SORT_DESC, $langs);
			$browserLang=substr($langs[0],0,2);

		} else {
			$browserLang=$defaultLang;
		}

		$requestedLang=Mage::app()->getRequest()->getParam('translateTo');
		//$requestedLang=$_REQUEST["translateTo"];
		$storeCode=Mage::app()->getStore()->getCode(); // store code
		$cookieName=$storeCode. "-". $defaultLang. "-jquery-translateTo"; // derive cookie name

		echo "// defaultlang - ". $defaultLang. "\n";
		echo "// requestedLang - ". $requestedLang. "\n";
		echo "// browserLang - ". $browserLang. "\n";
		echo "// storeCode - ". $storeCode. "\n";
		echo "// cookieName - ". $cookieName. "\n";
		echo "// langfromcookie - ". Mage::getModel('core/cookie')->get($cookieName). "\n"; 

		if(!empty($requestedLang)) // check for language setting in REQUEST key
		{
			if (strtolower($requestedLang) !== strtolower($defaultLang)) { // translate if requested language != to store default
				if (!empty($requestedLang))
				{
					echo "// translating to requested language from url variable.\n";
					echo "doTranslateTo('". $requestedLang. "');\n"; // Translate and write cookie data
					Mage::getModel('core/cookie')->set($cookieName, $requestedLang, time()+36000);
				} else {
					echo "// Requested Language not detected.\n";
				}
			} else {
				Mage::getModel('core/cookie')->set($cookieName, strtolower($defaultLang), time()+36000); // set cookie i.e. keep default lang when default selected
				//Mage::getModel('core/cookie')->delete($cookieName); // remove cookie i.e. revert to browser lang when default selected

			}
		} else { // check for language data in cookie

			$langFromCookie = Mage::getModel('core/cookie')->get($cookieName); // read cookie

			if (!empty($langFromCookie))
			{
				if (strtolower($langFromCookie) !== strtolower($defaultLang)) { // translate if language data in cookie != to store default
					echo "// translating to requested language from cookie data.\n";
					echo "doTranslateTo('". $langFromCookie. "')\n";
				} else {
					echo "// cookie requesed language same as store default language - no translation required.\n";
				}
			} else { // no cookie	

				if (strtolower($browserLang) !== strtolower($defaultLang)) { // translate to browser language and set cookie
					if (!empty($browserLang))
					{
						echo "// setting language to browser language.\n";
						echo "doTranslateTo('". $browserLang. "');\n";
						Mage::getModel('core/cookie')->set($cookieName, strtolower($browserLang), time()+36000); // set cookie
					} else {
						echo "// Browser language not detected.\n";
					}
				} else {
					Mage::getModel('core/cookie')->set($cookieName, strtolower($browserLang), time()+36000); // set cookie
				}
			}
		}
		?>			

	})
	//]]>
	</script>

The code includes two jQuery functions, one that performs the jQuery automatic translation, and the other that monitors the language dropdown box used to manually change the page translation. The PHP code controls the automatic translation of pages based on the visitors browser language, using a cookie to store the visitors language which is subsequently used to translate every visited page to the browser language, or the language selected from the select Language dropdown box which is passed to the script via a URL request variable. Note that the code detects the default locale for the Magento store and uses this as the default language for translations.

To add the dropdown box, locate the languages.phtml file in the template/page/switch folder of your theme. Make a backup of the original file and then edit it to add the Language selector drop down box, replacing the contents of the file with the following code which includes all the languages supported by Google. This file is also included in the download package.

The language dropdown has been updated to show the current language as selected in the drop down list.

<?php
/**
 * Language switcher for jQuery Automatic Translator for Magento
 * blog.gaiterjones.com
 *
 */

$defaultLang=substr(Mage::app()->getLocale()->getDefaultLocale(), 0, 2); // default store language
$storeCode=Mage::app()->getStore()->getCode(); // store code
$cookieName=$storeCode. "-". $defaultLang. "-jquery-translateTo"; // derive cookie name
$langFromCookie = Mage::getModel('core/cookie')->get($cookieName); // read cookie
$requestedLang=Mage::app()->getRequest()->getParam('translateTo');

if (!empty($requestedLang))
{
	$languageSelected=$requestedLang;
} else {
	$languageSelected=$langFromCookie;
}

$languagesSelection =
		array(''=>'Select Language',
				substr(Mage::app()->getLocale()->getDefaultLocale(), 0, 2)=>'Default Language',
				'af'=>'Afrikaans',
				'sq'=>'Albanian',
				'ar'=>'Arabic',
				'be'=>'Belarusian',
				'bg'=>'Bulgarian',
				'ca'=>'Catalan',
				'zh-CN'=>'Chinese (Simplified)',
				'zh-TW'=>'Chinese (Traditional)',
				'hr'=>'Croatian',
				'cs'=>'Czech',
				'da'=>'Danish',
				'nl'=>'Dutch',
				'et'=>'Estonian',
				'tl'=>'Filipino',
				'fi'=>'Finnish',
				'fr'=>'French',
				'gl'=>'Galician',
				'de'=>'German',
				'el'=>'Greek',
				'ht'=>'Haitian Creole',
				'iw'=>'Hebrew',
				'hi'=>'Hindi',
				'hu'=>'Hungarian',
				'is'=>'Icelandic',
				'id'=>'Indonesian',
				'ga'=>'Irish',
				'it'=>'Italian',
				'ja'=>'Japanese',
				'ko'=>'Korean',
				'lv'=>'Latvian',
				'lt'=>'Lithuanian',
				'mk'=>'Macedonian',
				'ms'=>'Malay',
				'mt'=>'Maltese',
				'no'=>'Norwegian',
				'fa'=>'Persian',
				'pl'=>'Polish',
				'pt'=>'Portuguese',
				'ro'=>'Romanian',
				'ru'=>'Russian',
				'sr'=>'Serbian',
				'sk'=>'Slovak',
				'sl'=>'Slovenian',
				'es'=>'Spanish',
				'sw'=>'Swahili',
				'sv'=>'Swedish',
				'th'=>'Thai',
				'tr'=>'Turkish',
				'uk'=>'Ukrainian',
				'vi'=>'Vietnamese',
				'cy'=>'Welsh',
				'yi'=>'Yiddish');
?>
<div class="form-language">
	<div class="language-switcher">
		<select id="langSelect" >
<?php
	foreach($languagesSelection as $langCode=>$LangName)
	{
		if ($languageSelected === $langCode)
		{
			echo '<option selected value="'. $langCode. '">'. $LangName. '</option>';
		} else {
			echo '<option value="'. $langCode. '">'.$LangName. '</option>';
		}
	}
?>
		</select>
	</div>
</div>

Save the file and refresh the Magento cache to load the new jQuery libraries and modified template files.

Testing

Now refresh your Magento front end and you should see the new language dropdown selector in the header of your page. This is where it appears in the default theme.

If your browser language differs from your stores default language then the page should automatically translate. If your browser language is the same as your stores, then perform a manual translation by selecting a language from the select language box. You will notice that a new request variable is appended to the site URL which triggers the dynamic translation. Navigate to other pages which should also become dynamically translated as the code reads the selected language from the cookie file. To turn off the automatic translation select the stores default language from the drop down, or select the second “default” option from the language dropdown list.

To manually link to a specific language for your site, specifiy the translation request variable in the URL with the two letter language code as shown above. i.e. for a German translation use http://www.webshop.com/?translateTo=de

Tested with Magento community editions v1.3.x and 1.5.x Please provide feedback if you experience any problems, have successfully implemented this solution or if you have any other ideas for further development.

Resources used in creating this solution

http://www.magentocommerce.com/wiki/4_-_themes_and_template_customization/javascript_related/how_to_use_jquery_1.2.6_lastest_with_prototype

http://code.google.com/p/jquery-translate/

http://jquery.malsup.com/block/

http://jsbin.com/ozenu/1007/edit

Update Links

http://code.google.com/apis/language/translate/overview.html

http://msdn.microsoft.com/en-us/library/ff512404.aspx

Blogged in Berlin.

I thought it would be a good idea to monitor this folder for new files and to be alerted by email when a change in the folder contents is detected, i.e. when a new error report is generated so that I am aware of Magento errors as soon as they happen.

I put together a quick PHP script and then converted it into a Magento Extension that runs as part of the magento scheduled cron tasks. The extension will check the /var/report folder every hour and send an email alert when a change in this folder is detected with the latest error report file attached.

The extension uses the Magento scheduler which should be enabled. And the Magento scheduler script cron.php should be configured to run periodically in your crontab.

To install the extension, copy the extension app folder to your magento store app folder. Refresh your magento cache. Logout from admin, and login again. Check out your var/reports folder, if you have not checked it for a while there could be reports there, it is quite safe to remove old reports.

The first time the extension runs you will receive an email if there are existing files in your var/report folder showing the total number of reports with the newest report attached. After that you will be alerted each time new reports are detected.

Configure the extension with a valid email addresses, in the My Extensions, Monitor Reports admin section.

Tested with Magento 1.3.x, 1.5.x

Download the extension here.