8 Indispensable Google Tag Manager Variables

Variables are dynamic bits of information that can be used within Google Tag Manager Tags, Rules, and even between Variables. They look something like this: {{Variable Name}}. These can get the value of 1st Party Cookies, JavaScript Variables, Data Layer Variables, and the ‘Custom JavaScript’ macro lets you extend the functionality of Variables nearly limitlessly. For a great overview of everything on offer, check out Simo Ahava’s complete guide to all of the default Variables. Here’s a list of some of my personal favorites.

1. User Agent

The User Agent is a string of text that identifies the “software (a software agent) that is acting on behalf of a user”. In our case, this is the browser and device used to access our website. For example, here’s yours:

You can test the User Agent to detect what browser a user is accessing your site with. This can be helpful if you want to track certain browser-based information (outside of what GA already collects) or change or exclude portions of your tag for users on particular browsers.

Since the User Agent is stored in the navigator.userAgent property, all you have to do is create a JavaScript Variable Variable (yes, ‘Variable Variable’) like below:

Select the variable type 'JavaScript Variable' and enter 'navigator.userAgent' into the input

For example, if you wanted to run a test and exclude any users of Internet Explorer 8 or below, you could do the following:

var isIeEightOrBelow = {{User Agent}}.match(/MSIE [2-8]/i) > -1 ? true : false;
if (isIeEightOrBelow) {
  // some code
} else {
  // some other code, or nothing.
}

You could also block an entire tag by using the same match as a blocking rule:
Blocking IE8 with Tag ManagerWARNING: User agent tests are often unreliable. Never hinge site-critical functionality on a user agent test; use feature detection instead.

2. Week of the Year

Having the week of the year handy is more useful than you might first expect; one thing I like to do is store the week and year with a converting user, so that I can perform acquisition cohort analysis within Google Analytics. This snippet (courtesy of RobG on Stack Overflow) extends the built-in Date object to allow you to get the current week of the year.

function() {
  Date.prototype.getWeekNumber = function(){
    var d = new Date(+this);
    d.setHours(0,0,0);
    d.setDate(d.getDate()+4-(d.getDay()||7));
    return Math.ceil((((d-new Date(d.getFullYear(),0,1))/8.64e7)+1)/7);
  };
  return new Date().getWeekNumber();
}

This is a great way to segment data and learn how user behavior changes over time. This can also be helpful for analyzing the impact new products or features has on your business.

Update: With the new Cohort Analysis Report, you can do some of this style of reporting natively. That said, you can only look at a limited set of cohorts in the data, so this is still a good back-up.

3. Mobile User

This is a snippet courtesy of Michael Zaporozhets on Stack Overflow; it’s a function that will return True if the user is on a mobile device, according to their user agent.

function() {
  window.mobilecheck = function() {
  var check = false;
  (function(a){if(/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i.test(a)||/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0,4)))check = true})(navigator.userAgent||navigator.vendor||window.opera);
  return check; }
  return window.mobilecheck();
}

This can be a useful piece of information if you’d like to prevent certain tags from firing on mobile devices, or if you’d like to exclude mobile users from a Content Experiment. The above warning about using the User Agent still applies.

4. The Page Title

This is a simple set of Macros that can come in handy for a number of reasons; say, for example, your site returns content on the same path, but with a huge variety in what content it returns based on some byzantine query string structure. In that case, the Page Title might expose some useful information. Fortunately, this is easily accessible through the document.title property. Just configure the Macro like you see below:
Select 'JavaScript Variable' for your Macro type, then enter 'document.title' in the input

Of course, Google Analytics will already capture the Page Title for you, but should you need to combine that data with another data point for deeper context, this is handy to have.

5. The Meta Description

The meta description can also be a useful piece of information to have, either to pull data from or to push into Google Analytics. One example of how this can be used is to fire an event on every pageview that stores the meta description and the URL it was fired on; this can be helpful for tracking down duplicate or blank meta descriptions. Of course, you can also see this data inside the HTML Suggestions section of Google Webmaster Tools.

function() {
  var metas = document.getElementsByTagName('meta');
  for (var i = 0; i 

Update: Jim Gianoglio of LunaMetrics fame pointed out that this could be accomplished JavaScript-free by using the below JavaScript Variable macro:
Example JavaScript Macro with document.head.children.description.content entered as the value

The value entered above is document.head.children.description.content, which will return the Meta Description or Undefined. Google Tag Manager helpfully catches errors for missing properties.

6. The Environment

If your site is developed and runs in several different environments, such as a development environment, a staging environment, and a production environment, it can be useful to modify tag behavior based on which enviroment the tag is operating in. For example, I wouldn't want my Google Analytics tag sending data to my production Google Analytics account from activity taking place in my development area. This could dirty my data with extra transactions, events, and other site metrics. Even a few extra test transactions run for Quality Assurance can skew the data.

There are a few ways to handle this.

A.) Have your developers populate the environment in the Data Layer

You can have your development team add a Data Layer variable that specifies what environment the site is currently being loaded in, like this:

var dataLayer = window.dataLayer|| (window.dataLayer = []);
dataLayer.push({'environment':'staging'});

B.) Detect the environment based on the hostname

If your development and staging environments live at different hostnames, like 'mysitestaging.com', you can create a Custom JavaScript Macro that returns the environment based on what it sees in the hostname, like this:

function() {
  var hostname = {{Page Hostname}};
  if (hostname === 'mysite.com') return 'Production';
  if (hostname === 'mysitestaging.com') return 'Staging';
}

Update: Pavel Jašek pointed out to me on Twitter that lookup tables could be used in place of custom JavaScript; this is a much better way to go about it. Something like below would suffice:
An example lookup table with a list of potential hostnames and their corresponding environment strings

C.) Detect the environment by testing something else

If, for some reason, your testing enviroment is operating at the same hostname that your production environment is in, you'll have to be creative and determine another authoritative test to run in order to figure out which environment you're running in. Here's a handful of ideas:

  • Try and access a service available only in one environment, like an outside API
  • Check the hostname of resources loaded on the page, like images, CSS, or JavaScript
  • Search external stylesheets or JavaScript for comments – typically these will be minified out in Production

7. The Google Analytics UA Number

The UA number is the number associated with the Google Analytics property that a hit is being sent off to. Having this handy can be useful for either configuring things on the fly or testing data before takng certain actions. If your site only operates in one environment, this is a snap:

function() {
  return 'UA-XXXXX-XX';  // Enter in your UA number here
}

Update: The above is a valid, but more roundabout way to accomplish this – I’ve left it there for posterity, but I would recommend instead using a Constant macro for a single UA number, like below:
Example Constant macro with a Google Analytics UA number stored as the value
However, if you’d like to use a different property for each environment (you should), then you might do something like this:

function() {
  var environment = {{environment}};
  if ( environment === 'Production' ) {
    return 'UA-XXXXX-XX';
  }
  if ( environment === 'Staging' ) {
    return 'UA-YYYYY-YY'; 
  }
}

Update: Per the above update, a lookup table would be a better option here. Here’s what it might look like:
An example lookup table for a Google Analytics UA Number, keyed by environment
Pavel also recommended this article on lookup tables by Simo Ahava.

8. Google Analytics User ID

Whenever a user visits your site, Google Analytics assigns them a unique, random identifier. This value is stored inside the cookie that Google Analytics sets on the browser. I like to capture it and store it inside Google Analytics as a Custom Dimension or Custom Variable; it can come in handy when trying to track down specific user behavior across visits or transactions.

There are two ways to get to this data – either by extracting it from the Google Analytics cookies directly, or, with the Universal Analytics library, asking for it politely.

Option 1: Cookie Sniffing

FOR CLASSIC ANALYTICS:
// Only works if __utma cookie has been set
function() {
  var __utmaCookie = document.cookie.match(/__utma=(.*?)(?:;|$)/);
  if(__utmaCookie && __utmaCookie[1]) {
    var utmaVals = __utmaCookie[1].split('.');
    if(utmaVals[2]) {
      return utmaVals[1] + '.' + utmaVals[2];
    }
  }
}
FOR UNIVERSAL ANALYTICS:
// Only works if _ga cookie has been set
function () {
  var _gaCookie = document.cookie.match(/_ga=(.*?)(?:;|$)/);
  if(_gaCookie && _gaCookie[1]) {
    return  _gaCookie[1].match(/\d+\.\d+$/)[0];
  }
}

Option 2: Asking Politely (Tracker Properties; Universal Only)

FOR UNIVERSAL ANALYTICS WITHOUT A NAMED TRACKER (TYPICAL):
function() {

  // Fetch the GA Library
  var gaLib = window[ window.GoogleAnalyticsObject ];
  var trackers = gaLib.getAll();
  var uaNumber = {{UA Number}};

  for ( var i = 0; i 

FOR UNIVERSAL ANALYTICS WITH A NAMED TRACKER (UNUSUAL):

function() {

  var gaLib = window[window.GoogleAnalyticsObject];
  var tracker = gaLib.getByName({{Tracker Name}});

  if(tracker) {

    return tracker.get('clientId');

  }

}

Those are some of my favorite Custom Variables; what are yours? Share with me on Twitter at @notdanwilkerson.

Average Session Duration – What is it and Why Bloggers Should Care

In Google Analytics, one of the statistics measures is average session duration. In simple terms, this is the amount of the time that a person spends on your website. This article will help you understand average session duration and if you’re a blogger, perhaps persuade you to take a better look into this piece of…

The post Average Session Duration – What is it and Why Bloggers Should Care appeared first on Diamond Website Conversion.

Using Offline and Online data to drive Google Analytics Remarketing

The Google Analytics platform has been changing from a web analytics tool to a user-centric digital measurement tool (we’ve been calling it Universal Analytics). This evolution includes a number of changes to the system and completely new features. But what can you do when you put all of these pieces together? I wanted to write […]

Using Offline and Online data to drive Google Analytics Remarketing is a post from: Analytics Talk by Justin Cutroni

The post Using Offline and Online data to drive Google Analytics Remarketing appeared first on Analytics Talk.

Understanding Google Webmaster Tools

As much as you might think Google is making it hard to get traffic, they really aren’t. They have tools like Google Webmaster tools and Google Analytics. The difference between the two are the fact that Google Analytics measures your traffic, and Google Webmaster Tools tells you how Google actually sees your website. This article…

The post Understanding Google Webmaster Tools appeared first on Diamond Website Conversion.

What Do You Do After You First Apply Google Anayltics to Your Website?

When you get into creating and managing a website, at some point you’re going to hear about Google Analytics, especially being told you need to have it on your website. Regardless if you’re a blogger, a small business owner, or a big corporate business, you do need a tool to measure your site’s progress. Google…

The post What Do You Do After You First Apply Google Anayltics to Your Website? appeared first on Diamond Website Conversion.

The Essential Guide To Error Tracking Using Google Analytics

Oft overlooked, error tracking is one of the most valuable ways to use Google Analytics. This essential guide covers how to use Google Analytics to track:

(click a link to jump ahead)

Using:

  • Google Tag Manager
  • Universal Analytics
  • Classic Google Analytics

404 Errors

Tracking 404s is great for:

  • Finding broken links (internal and external)
  • Proactively catching broken functionality
  • Tidying up older site architecture

Use Events to capture the previous page of the visit and the complete location of where the 404 occured. These are available at document.referrer and document.location.href, respectively. These two pieces of information can let you track down exactly where the offending link happens to be; capture these instead of relying on the ‘Page’ or ‘Full Referrer’ dimension in Google Analytics. Those values can easily be altered by filters, campaign parameters, or by other features built into Google Analytics.

FOR GOOGLE TAG MANAGER:

If you’re using Google Tag Manager, checking the title element for the default ‘404’ text is a sturdy test to fire a tracking event. Something like {{title}} equals '404 Page' or {{title}} contains '404 Page', as recommended by Samantha Barnes in her excellent guide to capturing 404 metrics with Google Tag Manager. You can also reference other tags that are on the page – be creative and find a standard value to watch for.

If that’s not possible, you’ll need to get your developers to populate the dataLayer with an event that you can watch for in Tag Manager, like:

var dataLayer = dataLayer||[];
dataLayer.push({'event':'404 Error'});

Then, you add a rule that watches for the 404 Error event, like so:

Then you create a Google Analytics Event tag and populate the Event Action and Event Label with the full URL of the page and the referrer.

As a best practice, I recommend that you try and decouple the mechanism that fires the event into Google Analytics from the actual event. Doing this means you can use a single ‘generic event’ tag to handle the processing of all of your events, and instead just push data into the dataLayer for the event tag to reference. For example:

In the above, each macro simply returns a corresponding dataLayer variable for an event value. It watches for ‘event’:’eventFired’ in the dataLayer. To generate a 404 event, all that needs to happen is the following be pushed into the dataLayer:

var referrer = document.referrer;
if (referrer === '') {
  referrer = 'No Referrer';
}
dataLayer.push({
  'event': 'eventFired',
  'eventCategory': '404 Error',
  'eventAction': document.location.href,
  'eventLabel': referrer,
  'eventValue': 0,
  'eventNonInteraction': true
});

This pattern makes adding future events a snap – all you have to do is push the ‘eventFired’ event into the dataLayer with the corresponding data; no need to create a whole new Google Analytics event tag.

If you’re not using Google Tag Manager, you’ll have to manually fire these events into Google Analytics. You can either include the following code as part of the 404 page template, or add it wrapped in a test into the header of each page on your site, e.g.:

if (document.title === 'Oops! You've found a 404 Page') {
  // Appropriate event tracking code from below goes here
}

FOR UNIVERSAL ANALYTICS:

var referrer = document.referrer;
if (referrer === '') {
  referrer = 'No Referrer';
}
ga('send', 'event', '404 Error', document.location.href, referrer, 0, {'nonInteraction': true});

FOR CLASSIC GOOGLE ANALYTICS:

var referrer = document.referrer;
if (referrer === '') {
  referrer = 'No Referrer';
}
_gaq.push(['_trackEvent','404 Pages', document.location.href, referrer, 0, true]);

JavaScript Errors

JavaScript errors are errors that the browser throws while executing the code that you’ve delivered to it. There are many common causes for JavaScript errors – browser compatibility, coding mistakes, and namespace collisions, to name a few. Tracking JavaScript errors can help you ensure a consistent user experience across browsers, catch bugs that were missed during development, and gauge the impact an error is truly having on users so that a fix can be appropriately prioritized.

FOR GOOGLE TAG MANAGER:

It’s your lucky day. Google Tag Manager offers a JavaScript Error Listener right out of the box. Just select ‘JavaScript Error Listener’ from the ‘Event Listeners’; I recommend you add this to every page.

Then, you’ll need to add another tag that listens for ‘gtm.pageError’ and uses the associated values to populate an Event for Analytics. I recommend reusing the pattern above for events, like this:

dataLayer.push({
  'event':'eventFired',
  'eventCategory': 'JS Errors',
  'eventAction': {{gtm.errorMessage}},
  'eventLabel': URL: {{href}} | File: {{gtm.errorUrl}} | Line: {{gtm.errorLineNumber}},
  'eventValue': 0,
  'eventNonInteraction': true
});

Otherwise, you’ll have to create another tag specifically for turning errors into events, like this:

I make the Event Action the gtm.errorMessage value and the Event Label URL: {{href}} | File: {{gtm.errorUrl}} | Line: {{gtm.errorLineNumber}}. This makes an for an easy-to-read format that can be drilled into for deeper context.

FOR UNIVERSAL ANALYTICS & CLASSIC ANALYTICS:

To track errors in the browser, you’ll need to bind an event listener to the window.onerror event that will generate a hit to send to Google Analytics. Doing this in a 100% backwards-compatible, error-free way can be super tricky, but here’s a copy-and-paste-friendly snippet you could utilize that should work with most browsers and Google Analytics configurations. Feel free to copy and modify to your tastes:

if (typeof window.onerror === 'object' && window.onerror === null) {  // Checks if this seat is taken/exists
  window.onerror = function(message, file, lineNumber) {
    if (typeof ga === 'object') {  // Detects Universal Analytics
      ga('send','event','JS Error', message, 'URL: ' + document.location.href + '| File: ' + file + '| Line: ' + lineNumber, 0, {'nonInteraction': true});
    } else if (typeof _gaq === 'object') {  // Detects Classic Analytics
      _gaq.push(['_trackEvent','JS Error', message, 'URL: ' + document.location.href + '| File: ' + file + '| Line: ' + lineNumber, 0, true]);
    }
  }
}

Server-side Errors

Sending application error data into Google Analytics directly from your server let’s you connect backend performance with front-end behavior. It can also contextualize seemingly unconnected issues across your site.

FOR GOOGLE TAG MANAGER:

Although technically not server-side, you could expose some error information into the dataLayer and then pass it into Google Analytics. On your server, this might look something like:

var dataLayer = dataLayer||[];
<?php
foreach ( $err in $errors ) { ?>
  dataLayer.push({
    'event': 'eventFired',
    'eventCategory': 'Server Error',
    'eventAction': '<?php echo $err->errno . $err->errstr ?>',
    'eventLabel': 'URL: ' + {{href}} + '| File: <?php echo $err->errfile ?> | Line: <?php echo $err->errline ?>';
  });
<?php } ?>

And on the client, you’d see:

<script>
  var dataLayer = dataLayer||[];
  dataLayer.push({
    'event': 'eventFired',
    'eventCategory': 'Server Error',
    'eventAction': 'Fatal error: Undefined class constant "MYSQL_ATTR_USE_BUFFERED_QUERY"'
    'eventLabel': 'URL: http://example.com/test/ | File: /local/www/example.com/includes/database/mysql/database.inc | Line: 43',
    'eventValue': 0,
    'eventNonInteraction': true
  });
</script>

Sidenote:

You’ll notice me using the syntax var dataLayer = dataLayer||[]; and then using dataLayer.push({}) in order to populate the dataLayer in my code; I recommend this as best practice to avoid accidentally overwriting needed information in the dataLayer. Basically, this is read by the browser as ‘The dataLayer is equal to itself, or it’s an empty array’. If the dataLayer doesn’t exists, the next section of the ‘OR’ (||) statement is evaluated, namely ‘dataLayer is an empty array’. In this way, if it exists, it will preserve itself, and if it doesn’t, it will create a new array named dataLayer for us to use.

Not instantiating dataLayer in this way can lead to problems if your code gets messy. For example, if you’re loading the dataLayer at the top of the page, then server errors inside the <content> of the page, this could happen:

<!-- Other HTML -->
<script>
  var dataLayer = [{'PageType':'Local'}, {'timestamp': 2849200492}];
  console.log(dataLayer); // Logs '[ { "PageType": "Local" }, {'timestamp': 2849200492} ]'
</script>
<!-- Other HTML -->
<script>
  var dataLayer = [{'event': 'Server Error'}];
  console.log(dataLayer); // Logs '[ { "event": "Server Error" } ]'
</script>

Should you need to reference either the PageType or timestamp values later, they would return undefined. Using dataLayer = dataLayer||[]; and then dataLayer.push() instead of just instantiating the dataLayer prevents this from happening.

FOR UNIVERSAL ANALYTICS:

The Universal Analytics Measurement Protocol provides a relatively painless way to send hits to Google Analytics directly from your server. All it takes is a POST request, which can be pretty simple to put together. Here’s a quick and dirty example using NodeJS:

var http = require('http');

function fireMeasurementProtocolEvent(category, action, label, value, nonInteraction, cid) {

  var ni = !nonInteraction ? '1' : '0';

  var eventData = "?v=1&tid=UA-XXXXXXX-XX&t=event&cid=" + cid + "&ec=" + category + "&ea=" + action + "&el=" + label + "&ev=" + value + "&ni=" + ni;

  var payload = {

    'hostname': 'www.google-analytics.com',
    'path': '/collect' + eventData,
    'method': 'POST'

  };

  var req = http.request(payload);
  req.end();

};

FOR CLASSIC GOOGLE ANALYTICS:

The truly intrepid can manufacturer fake __utm.gif requests – all you need to do is generate a GET request to http://www.google-analytics.com/__utm.gif with the correct parameters appended to the request. Here’s a great reference from Google on how to do just that.

Modal & Dialog Errors

Finally, a great ‘error’ type that I like to catch is any kind of modal or error dialog presented to a user. Even mundane error messages can reveal more sinister patterns lurking underneath. Tracking and analyzing common site messages is essential for good site hygiene.

FOR GOOGLE TAG MANAGER:

Either create an event tag and a macro to grab the text of the modal, or using the generic tracking event outlined above:

var modal = document.getElementById('modal-message');
dataLayer.push({
  'event': 'eventFired',
  'eventCategory': 'Error Modal',
  'eventAction': modal.textContent,
  'eventLabel': '',
  'eventValue':0,
  'eventNonInteraction': true
});

FOR UNIVERSAL ANALYTICS:

var modal = document.getElementById('modal-message');
ga('send', 'event', 'Error Modal', modal.textContent, '', 0, {'nonInteraction': true});

FOR CLASSIC GOOGLE ANALYTICS:

var modal = document.getElementById('modal-message');
_gaq.push(['_trackEvent','Error Modal', modal.textContent, '', 0, true]);

Have any error-collecting techniques of your own that I missed? Tweet them to me at @notdanwilkerson.

Heartbleed Bug Vulnerability Detection and Correction

For those who may not know, I write most of my posts over at one of my newer sites The Ecommerce Expert now. Most of my activity has moved there so be sure to head on over and subscribe to get the latest updates. With that said, I thought it would be important to post […]

Heartbleed Bug Vulnerability Detection and Correction is an article taken from: Ecommerce Optimization & Marketing protected under copyright law. Reproduction in any form without consent is strictly prohibited.

If you want to find out how to increase your website conversion, increase sales, and win more customers you should visit the original Ecommerce Optimization site.

The post Heartbleed Bug Vulnerability Detection and Correction appeared first on Ecommerce Optimization & Marketing.