But the biggest news, and the subject of this post, is the introduction of a new Event Flow report to track users through a series of events.

NEW! Google Analytics Event Flow Reports

When the world was focused on web analytics a common analysis technique was path analysis. The goal was to find the “magic path” through the website that lead to the most conversions and then force everyone through that process.

We almost never found the “magic path.” But there are some uses for path analysis, like looking at a defined path, for example a checkout process, and identifying where people leave the process.

But things have changed.

In the new world of digital analytics we collect more than just pageviews. We also collect events, which we use to track the minute details of how people interact with a website or app.

Until now we had no way to understand the sequence, or flow of these events. The Google Analytics Event Flow report provides a visualize of the user path between events.

If you’ve used the Flow Visualization reprots in Google Analytics then the Event Flow reports will look very familiar. It’s the same report. The only difference is that the event flows reports show events.

The event flow report can really be used for anything. It’s really up to you, and how you use events. A few that come to mind:

• If you’re an automotive site, you might use it to track people using a vehicle configuration tool
• If you’re a financial site, you might use it to track how people use a mortgage calculator
• If you’re tracking an app with Google Analytics, you might use this to track interactions
• If you’re tracking video streams with Google Analytics, you might use this to track how people flow from one stream to another

Before we get into an example, I should point out that this is all based on event data. If you don’t use event tracking this report will be useless. Or, if you have really bad events, this report will not work for you.

Make sure you have great events!

Overview

As is the case with the standard Flow Visualization report, the new Event Flow report consists of segments, nodes and paths. You can view the flow of a specific segment through the report using the segments on the left side. Or you can segment the entire flow using the drop down at the top of the report.

You can view various segments of traffic through the Event Flow or segment the entire flow.

Nodes represent either an event category, an event category/event action combination or a category/action/label combination.

Example

Last month I wrote about a new way to track content engagement with events. Using some custom code to can generate events as people scroll through a page and read content.

The data generates a model of the reading process. Events are generated at the following times:

• When an article is loaded in the browser
• When a visitor starts reading (by tracking scrolling)
• When a visitor gets to the bottom of the content
• When a visitor gets to the bottom of the page

We can now visualize the above process with the Event Flow report. I not only want to visualize the above process, but I want to see how people might jump steps in the process.

You can choose to view a different combination of events in the Event Flow.

Here’s a tip, the size of the nodes change depending on the event combination you choose to view. If you choose to only view the event categories, you’ll have a few, large nodes. But, if you choose to view the categories/actions/labels you’ll have LOTS of nodes.

I find that starting with the category/action combination is usually sufficient.

There are a lot of events here, so I’m going to click on a node and choose Highlight. This shows the traffic through the chosen node, which in this case is the category/action of Reading/ArticleLoad. Now I can see the path of all the traffic that loaded an article.

You can highlight traffic through a specific event node in Google Analytics.

The visualization shows traffic that came to the site, loaded an articles, read the article, hit the content bottom and hit the bottom of the page.

Using the Google Analytics Event Flow to visualize a series of event. In this case how people read content on a website.

I was able to see the percentages of traffic that move from step to step in the tabular data. But a visualization makes it easier to identify drop-offs.

Here’s something interesting. Using tabular data I learned that 67% of those that start reading get to the bottom of the content and 9% get to the bottom of the page.

Very few people read all the way to the bottom of the page. What happens after people get to the bottom of the content? Do they leave the site?

Using the flow I can easily get the answer.

I can literally see four actions when people hit the bottom of the content:

• Some people exit the site (the RED comments below
• Some move on to a new article (the BLACK comment below)
• Some read to the bottom of the page (the BLUE comment below)
• Some convert at a goal (the YELLOW comment below)

Analyzing what happens during a series of events.

You’re probably wondering how I can get more detail, perhaps view this flow on an article-by-article basis. Well, if I was tracking the article name in the event label I’d be able to see that! But I’m not doing that. Yet.

So there you have it. One application of the Event Flow reports.

How do you plan to use the Event Flow reports?

Go With The (Google Analytics Event) Flow is a post from: Analytics Talk by Justin Cutroni

Related posts:

1. Path Analysis in Google Analytics with Flow Visualization
2. Event Tracking Pt. 3: Reporting & Analysis
3. Event Tracking Pt. 1: Overview & Data Model

Event tracking is a flexible, data collection mechanism that you can use to track almost anything. From video players, to mortgage calculators, to mobile apps, events are a way to collect and count visitor actions. While the data may seem simplistic, it’s valuable insight into visitor behavior.

But event tracking can be hard to implement, especially if you don’t know how to code. Even if you do know how to code, managing a larget amount of events can be a challenge. I wanted to push out a couple of tools to make implementing and maintaining events easier.

A Quick Review of Google Analytics Events

There are five parts to an event: category, action, label, value and a flag that controls interactivity.

• Category: The category is at the top of the hierarchy. It’s a way to bundle visitor activity together. It encompassed all of the other event data.
• Action: The action is literally what the visitor does. In our video player example some potential actions might be: play, pause, share, get embed link, etc.
• Label: Provides a bit more information about the visitor’s action. For example, if you are using events to track a video player you might record the movie name as the label when an action occurs. That provides more context to what the visitor is doing.
• Value: Any positive integer value. It’s a number. You can use it to count things, like dollars or seconds. If you choose to use your event as a goal, then you can specify that Google Analytics use the event value as the goal value.

The last event setting is a bit different. It’s called non-interactive and it is used to alter how Google Analytics interprets the event data. Normally, when an event is sent to Google Analytics, the system recognizes the user as interacting with the site. So it records that the visit is NOT a bounce, even if the visitor only sees one page.

But there may be a case where you want to track the visitor interactions with events AND bounces. In those cases you can set the non-interactive value to true and GA will still count a bounce.

Setting up an event is a four step process:

1. 1. Design your event data (ie write down you categories, actions, labels, etc.)
2. 2. Identify where you need to put the event code
3. 3. Add the code to the appropriate places of your site (or app, or whatever)
4. 4. Analyze data

My goal with the tools below is to help you with step 1, and to some extent step 2. But remember, you need to add this code to the correct parts of your site.

Event Creator Tool

Below is an Event Code creator. I wanted to create something where anyone can enter in their values for an event and have the code automatically generated. If you’ve ever used the Google Analytics Link Tagging tool then you’ll be able to use the Event Creator.

Remember, you’ll still need to attach this code to the appropriate place to capture the visitor action.

[iFrame below, if you can't see it please visit the site.]

In addition to the standard event data, you can select added a few formatting options:

• Force Lowercase: This setting forces the event values to lowercase. This can increase the consistency of your data by making everything the same case. You don’t need to force everything to lowercase, but make sure you’re consistent!
• Replace White Space: This setting will strip out all of your white spaces. Again, this is not necessary, but it can make your data more uniform.

This tool may seem very simplistic, but it is a very good learning tool. If you’re trying to show someone how to take an event from idea to code this can be very useful.

Event Management Worksheet

If you run a large site, then you probably work with a lot of events. As a result the event creator tool is not very useful. It just doesn’t scale.

A good alternative is using a Google Doc with an embedded formula. It does the same thing as the form above, but you can crag the formula to create a lot of code quickly. You can enter all the standard event values, then drag the forumla in column F to create the event code. You can also add a description of what the event does and a note about where in the code the event should be placed.

[iFrame below, if you can't see it please visit the site.]

I personally like to do this with a Google Spreadsheet, so I can share it with other people at a company. But you can use the “other” spreadsheet program if you like :)

Tools to Help Organize Google Analytics Events is a post from: Analytics Talk by Justin Cutroni

Related posts:

1. Tools for Debugging Google Analytics
2. Tools fo Debugging Urchin Software
3. Event Tracking Pt. 2: Implementations

Do people actually read content?

The default content tracking content in Google Analytics is fairly straight forward. Using the standard page tag you can get all sorts of information like time on page, bounce rate and pageviews.

But sometimes this is not enough. For publishers and minor bloggers (like your’s truly) these metrics can be sub-optimal.

I want more detailed information about each article. Do people read the comments or do they just read the post? Do they open a lot of posts in tabs?

What would be better is a way to measure more detailed information about how website visitors interact with each page.

So that’s what this post is all about: measuring how people interact with content using custom tracking.

Some Thanks

Before we begin, this blog post, technique and concept was born from collaboration. There are a number of people that need to be recognized for contributing. You can read more about the genesis of this technique at the bottom of the post. Contributors include:

Nick Mihailovski – Developer advocate at Google (and the guys that sits across from me)
Thomas Baekdal – Smart guy and publisher of www.baekdal.com
Avinash Kaushik – If you don’t know Avinash…
Joost de Valk – Creator of the Google Analytics for WordPress
Eivind Savio – Blogger and GA consultant

Now, on the details!

Business Objective

As I mentioned above the objective here is to get a better understanding, on a page by page basis, of the content that visitors engage with. Using some objectives suggested by Thomas Baekdal here’s what we’re going to track:

• How many people scroll
• When a person starts to scroll
• When a person reaches the end of an article (not the end of the page, but the end of the article or post area)
• When a person reaches the botton of the page (the bottom of the HTML)
• Which website visitors are scanning my articles and which are reading my articles

Think about the value here! We will be able to get an accurate measure of which articles are actually read. We can even see which articles are so engaging that visitors continue through the comments to the botto of the page. Very useful stuff.

Tracking Technique

All of the above can be tracked with Event Tracking. The concept is that we will fire events when certain actions happen. Specifically we’re going to fire events based on visitors scrolling down the page.

Critical to any event tracking implementation is the data model. We need to define the data we want to see in Google Analytics.

All of the reading activities will be grouped together into a category named Reading.

Within this category there will be four main actions:

• Article load: Measure how many times the article loads in a browser. Basically another count of pageviews. This will provide context to the other events that we track.
• Start Reading: Track when a visitor starts scrolling down the page. This will be triggered after a visitor scrolls 150 pixels down the page. This value can be customized. I’m also tracking how much time it takes to start scrolling.
• Content Bottom: Track when a visitor reaches the end of the article content. And track how much time it took between the scroll start and getting to the bottom of the content.
• Page Bottom: Track when the visitor reached the botton of the page and how long it took.

Another piece of critical information is the page URL and title. We need this to segment the data and see which articles are most engaging to people. Google Analytics will automatically track the page URL and title so there’s no need to add it to the event.

We’re also going to use a Custom Variable to place this visitor in a bucket. If it took them less than 60 seconds to get to the bottom of the page then I will assume they are just scanning. We’ll put them in the Scanners bucket.

But, if they took longer than 60 seconds to get to the bottom of the page then we’ll put them in the readers bucket.

FInally, I can set these events up as goals. I’ll add one goal for those that make it to the bottom of the content and one goal for those that make it to the bottom of the page. This is an easy way to measure what percentage of visits complete these actions.

The Code

First, this code uses something called jQuery. It’s a special JavaScript library that makes it easier to program complex tasks. Almost every website is running jQuery these day. But make sure your site includes the library.

Here’s the code, feel free to copy, tweak and share. Just remember all the people that contributed to it!

[ If you don't see an iFrame below, please visit the site. ]

We start with some simple declarations. These control flow etc. But notice there are a couple values you can change.

// Debug flag
// CHANGE THIS TO false BEFORE INSTALLING
var debugMode = true;

// Default time delay before checking location
var callBackTime = 100;

// # px before tracking a reader
var readerLocation = 150;

// Set some flags for tracking & execution
var timer = 0;
var scroller = false;
var endContent = false;
var didComplete = false;

// Set some time variables to calculate reading time
var startTime = new Date();
var beginning = startTime.getTime();
var totalTime = 0;

You can change the callBackTime variable and the readerLocation variable. callbackTime is the time (in millisecond) that the browser will wait before checking the scroll location. This eliminates any lag in scrolling.

readerLocation is the distance, in pixels, that the visitor must scroll before we fire an event and classify them as someone who starts reading.

Now we send off an event to track that the article has loaded:

// Track the aticle load
if (!debugMode) {
_gaq.push(['_trackEvent', 'Reading', 'ArticleLoaded', '', , true]);
}

Next comes the code that checks the location. First we gather where the visitor is on the page and how far they have scrolled.

bottom = $(window).height() + $(window).scrollTop();
height = $(document).height();

Then we start checking.

First, have they scrolled enough to fire the first event (150 px)?

// If user starts to scroll send an event
if (bottom > readerLocation && !scroller) {
currentTime = new Date();
scrollStart = currentTime.getTime();
timeToScroll = Math.round((scrollStart – beginning) / 1000);
if (!debugMode) {
_gaq.push(['_trackEvent', 'Reading', 'StartReading', '', timeToScroll]);
} else {
alert(‘started reading ‘ + timeToScroll);
}
scroller = true;
}

IMPORTANT: The above event WILL change your bounce rate. As soon as someone starts scrolling I consider them engaged and not a bounce. So this event will drop your bounce rate. Also note that these events WILL change your time on site calculations. You should see time on site increase.

Then, when they reach the bottom of the content area, this event fires marking their progress. I’m basically checking to see if the div that contains the article content has been reached. If so, fire the event.

// If user has hit the bottom of the content send an event
if (bottom >= $(‘.entry-content’).scrollTop() + $(‘.entry-content’).innerHeight() && !endContent) {
currentTime = new Date();
contentScrollEnd = currentTime.getTime();
timeToContentEnd = Math.round((contentScrollEnd – scrollStart) / 1000);
if (!debugMode) {
_gaq.push(['_trackEvent', 'Reading', 'ContentBottom', '', timeToContentEnd]);
} else {
alert(‘end content section ‘+timeToContentEnd);
}
endContent = true;
}

It’s really important to note that the above code looks for a div specific to my blog. On my site the div is named entry-content. It might be different on yours. Basically you’re looking for the container that holds the blog post or article.

Finally, we track if the visitor got to the bottom of the page. Here we do a few things.

1. We calculate how long it took them
2. We send an event
3. We set a custom variables to bucket our traffic. If the visitor took longer than 60 seconds to reach the bottom then we’ll put them in the reader segment using a visit level custom variable. If they take less than 60 seconds I’ll put them in the Scanner bucket.

I’m putting them into custom variable slot 5 because that’s the only slot that I have available. You may need to use a different slot. Dont know what a slot is? Read more about mastering custom variables.

// If user has hit the bottom of page send an event
if (bottom >= height && !didComplete) {
currentTime = new Date();
end = currentTime.getTime();
totalTime = Math.round((end – scrollStart) / 1000);
if (!debugMode) {
if (totalTime < 60) {
_gaq.push(['_setCustomVar', 5, 'ReaderType', 'Scanner', 2]);
} else {
_gaq.push(['_setCustomVar', 5, 'ReaderType', 'Reader', 2]);
}
_gaq.push(['_trackEvent', 'Reading', 'PageBottom', '', totalTime]);
} else {
alert('bottom of page '+totalTime);
}
didComplete = true;
}

Since we’re collecting the time spent on page, I’m going to use this data to adjust the threshold after I collect some data. I chose 60 seconds arbitrarily.

And finally, here’s the code that actually checks if the visitor has scrolled down the page:

// Track the scrolling and track location
$(window).scroll(function() {
if (timer) {
clearTimeout(timer);
}
// Use a buffer so we don’t call trackLocation too often.
timer = setTimeout(trackLocation, callBackTime);
});

So that’s the code. You can copy it from the iFrame above and place it on your site if you want to.

A Bonus For WordPress Users

All of this awesomeness will be added directly into the Google Analytics for WordPress plugin developed by Joost. Look for it soon.

Stay tuned for a post tomorrow about the resulting reports!

Advanced Content Tracking with Google Analytics: Part 1 is a post from: Analytics Talk by Justin Cutroni

Related posts:

1. Tracking Clicks with GA Pt. 3: Advanced Implementation
2. Event Tracking Pt. 2: Implementations
3. Content Optimization With Google Analytics, Part 1

But what about YouTube videos that are embedded in a site? What’s the best way to measure interactions with these videos? You could use some basic metrics like Avg. Time on Page and Avg. Time on Site, but they’re averages and, well, averages suck. Fear not, there is a better way.

We can track almost every aspect of an embedded YouTube video using Event Tracking, a Google Analytics beta feature.

There is one catch. In order to track an embedded YouTube video you must use the ‘chromeless’ YouTube player. A chromeless video player has no controls which means you must create all of the controls yourself. This results in a fair amount of coding.

Why do we have to use the chromeless player? The chromeless player let’s us add JavaScript code (i.e. GA Event tracking code) to user actions, thus giving us the ability to capture visitor actions as events. I’ll do my best to walk you through all of the code.

You can read more about the chromeless YouTube player on the YouTube developer site.

Let’s get started.

Event Data Model

Before we look at any code let’s talk about data and analysis. One of the keys to any successful event tracking implementation is a clear definition of the data we want to collect. Remember, event tracking is really a flexible data collection tool. We need to explicitly define the data we want to collect.

I want to track three primary things related to the embedded video:

1. Which video does the visitor choose to watch?
2. How do they interact with the video player (i.e how do they use the controls)?
3. How much time do they spend watching each video?

Now let’s translate these needs into the Google Analytics Event model which consists of Objects, Actions, Labels and Values.

Objects

The object is the part of the page that we want to track. Defining the object in this case is pretty simple: we want to track the YouTube video player, so we’ll create one object and call it “YouTube Video Player”. The object will literally be created in the code and I’ll explain how later.

Actions

Actions are the interactions that the visitor exerts on the object. What we want to track, and what we can track, really depend on what interactions we can capture. In this example, the actions we can capture are directly related to the chromeless YouTube player and what it ‘bubbles up’ for visitor interactions.

Based on the chromeless player, and the data needs we have defined, here are the actions that we are going to track:

• Player Loaded: Indicates the YouTube player has loaded. No video has been loaded into the player, but the player is ready for a video.
• Video Started: Indicates the user has chosen a video and it has started playing in the player.
• Play: User has restart the video after it has been paused.
• Pause: Video has been paused.
• Mute: Video has been muted.
• Unmute: Video has been unmuted.
• Error: An error has occurred.
• Ended: Selected video has ended, either intentionally or on purpose by the visitor.
• Get Embed Code: Request HTML code to embed the video in a site.
• Get Video URL: Request YouTube URL for the current video.

Like the object, actions are actually created in the code and we’ll see how later.

There are other things that we can track, but I’ve decided to limit it to the above list. Why? I don’t think there is a lot of insight that can be gained from some of the other information that is available to us. Plus the above actions will cover the data needs we’ve defined.

Labels

Labels are the content of the object. In the case of most video player object, the label will be the name of the video playing. In this example you can choose three potential videos from a drop down box. The name of the video will become the label that is tracked in Google Analytics.

• Apollo 11 Launch
• About the YouTube API
• Phish – Weekapaug Groove
• Authors@Google: Avinash Kaushik

Values

This is where things can get a bit unique. The value collected by GA’s Event tracking is just a plain integer. All values associated with actions are summed and averaged. So we can’t mix different types of data, like monetary values (which may be in dollars) and time (which may be in seconds). For this example, we’re going to track time, so the values will be in seconds and will represent the total time that each video played.

I’m only going to associate a value with a single actions: Ended. When a video ends we’re going to record the total number of seconds played for that video.

The Example

Now that we’ve created the data model for tracking a YouTube player, we need to create a YouTube player to track. :) Remember we can only access visitor actions when we use the chromeless YouTube player.

Here’s a simple page that I created using the chromeless player and Google Analytics Event Tracking.

If the above iFrame is not visible, you can view the entire code here.

For those interested, this test page is actually a modification of the YouTube API example.

To start the tracking, select a video from the drop down and it will start playing. Then experiment with some of the controls. All actions that we defined in our event model will be tracked.

If you want to change videos just choose a new video from the drop down box.

I don’t want to go over too much of the code, but here’s the JavaScript behind the tracking.

If the above iFrame is not visible, you can view the entire code here.

A majority of the code is not Google Analytics code, but rather YouTube player code. What I’ve done is added the Event Tracking code in the appropriate places to capture the visitor interactions. Setting up the event tracking code is really pretty simple.

The first thing I did was create the Object, which is called ‘YouTube Video Player’. I created the object in the main GA page tag.

<script type='text/javascript'>
var pageTracker = _gat._getTracker("UA-XXXXXXX-X");
pageTracker._initData();
pageTracker._trackPageview();

// Create the event tracking object
var ytpEventTracker =
pageTracker._createEventTracker("YouTube Video Player");
var eventLabel;
</script>

After creating the object I added the _trackEvent() method wherever I want to capture a visitor action, like Play or Pause. Here’s how I capture the Play action:

function play() {
  if (ytplayer) {
    ytplayer.playVideo();
    ytpEventTracker._trackEvent("Play",eventLabel);
  }
}

Most of the Play code is actually YouTube code. The only GA specific code is ytpEventTracker._trackEvent("Play",eventLabel);.

We pass three values to _trackEvent(). The first is the name of the action and this value will appear in the GA Actions report. The second value is the lable value which will appear in the Labels report. I should note that eventLabel is the name of the video (per the data model) that is currently playing when the visitor clicks on Play.

The final value, which is not shown above, is the value value. In this example, the value is the total number of seconds played. This is only recorded for the Ended action.

If you look at the example code, all I really did was add ytpEventTracker._trackEvent() to all the actions that I wanted to track.

The Results

Enough with all the techno-mumbo-jumbo. Let’s look at some of the data starting at the top of our hierarchy: the Object report.

Noting too exciting here. We’re only tracking a single object here, hence the one line of data. The data can be a little confusing. The total number of events is really the total number of actions that occurred. The number of unique events is the number of visits that included an event.

But let’s dig a bit deeper. Let’s see which video was most popular by viewing the labels associated with the YouTube Video Player object. All I need to do is click on the Object name to view the associate labels and actions, and then choose ‘Labels’ using the Detail Level link above the table tabs.

Here we can see that ‘Phish-Weekapaug Groove’ was the most popular video, when based on time. It had a higher total value than the other videos. Sorry Avinash. :)

One thing to notice is that measuring the popularity of each video based on Events is not correct. Just because a label has the most actions does not mean that it is the most popular.

Remember, an action can occur ever time a visitor interacts with the player. In this example it would be more accurate to judge popularity based on time.

Now let’s see how people interacted with the most popular video. What actions did visitors perform when ‘Phish-Weekapaug Groove’ was playing?

All I need to do is click on the label name to see the actions associated with the label.

Cool, here we can see that the video was started 32 times, but only completed 12 times. It was viewed a total of 1775 seconds but only an average of 143 seconds.

What does it all mean? I know that the Phish video is 179 seconds long. So, on average, visitors viewed 80% of it. I can also tell, by the number of unique events, that the Phish video was viewed multiple times in the same visit. It must be pretty popular.

I also want to point out that we can view the data in other ways. We can navigate directly to the Actions report to see a list of all the actions, regardless of the object or label they are associated with. This is a great way to get a feel for the most commonly used features of our YouTube player.

Conclusion

So was this really worth it? Sure, I think so. I wanted to create a real life example that demonstrates some of the ways to use Event Tracking. I also wanted to use YouTube as an example because so may people use it as a platform to distribute video.

While it may seem like a lot of work to track video and other web 2.0 technologies it is vital. If you’re spending money producing videos, or if you’re selling video ad space, you need to know how people interact with your player and content. It’s the perfect use for Event Tracking.

Tracking YouTube Videos with Google Analytics is a post from: Analytics Talk by Justin Cutroni

Related posts:

1. Event Tracking Pt. 3: Reporting & Analysis
2. Event Tracking Pt. 1: Overview & Data Model
3. Event Tracking Pt. 2: Implementations

What Are Events

Events are actions that visitors take on a web page that don’t generate new pageviews. Interacting with a video player, a widget or an audio player are all common events. Tracking these interactions provides a lot of insight into what visitors are doing on a page.

In the old GA we could track this data as a pageview. But this was really ineffective. First, it created lots of pageviews that polluted our true pageview numbers. Second, the reporting wasn’t built to handle events so it never provided any real insight. That’s why we now have event tracking.

Event tracking adds another layer of data to the visitor data hierarchy:

Visitors
Visits
Pageviews
Events

Now we can really get a good idea of how visitors are engaging our interactive content. This will be vital as web technologies, like Ajax and Flash, continue to evolve.

Every time an event occurs GA will increase the event counter. So if we’re tracking the click button event, GA will show us an agregate count of the clicks. I’ll cover the reporting in Part 3.

Start With Business Questions

Before I get into the structure of event data, I want to talk about analysis. All analysis starts with a business question. What is the most popular organic keyword that visitors searched for? How many sales did I have last week? What was the revenue for a specific campaign? Normally, when you’re using GA, you don’t need to do any special configuration to answer these questions. GA does most of it for you.

But with events, you need to create ALL of the data that will end up in GA. You literally need to define what data you want GA to collect both in name and in value. If you don’t know what business questions you want to answer, you won’t be able to create the correct data.

As I continue this post, I’m going to use an example, Google Maps. If I was an analyst for Maps I would want to answer a lot of questions:

How many people use the zoom and do they zoom in or out?
Which map view is most popular: map, satellite, hybrid, etc.
How many people drag a map waypoint to a new location?

To make things easy, let’s focus on one question: which map view its the most popular. So now that we know the question we want to answer, let’s talk about the data we need to answer it.

Understanding the Data Model

There are 4 parts to the events data model:

Objects
Actions
Labels
Values

Objects

Objects are parts of pages that we want visitors to interact with. This may be a video player or a cool Ajax widget. To continue our example, the object would be ‘Map’. Remember, the business question we want to answer concerns a feature in the map.

Actions

The second part of the data model is Actions. Actions are attached to an object and represent the actions that visitors perform on our object. Actions tell us what the visitor did.

There can be lots of actions associated with an object. Just think about our map. There are so many things that a visitor could do. But we want to define actions that relate directly to the business questions. Here are a few actions that our Map object might have:

Zoom
Change view type
Drag waypoint

Because we’re focused on one business question, we’re going to focus on one action: ‘Change view type’.

Labels

Labels quantify the action that occurred. If the actions tell us what the visitor did, the value tells us the result. So, for the ‘Change view type’ action that I created above, I might have the following labels:

Satellite
Map
Hybrid
Street view

Labels are really important to understanding actions. If an actions only has one value it does not provide any insight into what the visitor did.

Values

The final part of the data model is Values. Values are optional but can provide a lot of insight into certain events. Values can be any type of numeric data that indicates the value of the action and label. While there are not may good values for our example, let’s assign a monetary value to each label. Who knows, maybe someone viewing a hybrid map is worth more than someone viewing a regular map:

Satellite 5
Map 10
Hybrid 15
Street view 20

Values can also be monetary making it easy to identify what actions have real value.

Pulling it All Together

So let’s look at our business question and the data model we’re going to use to answer it.

Questtion:
Which view type do people use more?

Object:
Map

Action:
Change view type

Labels & Values:
Map 5
Satellite 10
Hybrid 15
Street Level 20

The next step is to implement the data model using event tracking code. That’s covered in Part 2. Oh, if the Google Maps team is reading, call me. I’m more than happy to lend a hand. :)

Event Tracking Pt. 1: Overview & Data Model is a post from: Analytics Talk by Justin Cutroni

Related posts:

1. Event Tracking Pt. 3: Reporting & Analysis
2. Event Tracking Pt. 2: Implementations
3. Google Analytics Campaign Tracking Pt. 0: An Overview

The Data Model

If you remember part 1, I created a data model for our event data. This will help us answer our business question and it will help use create the code.

Tag Your Pages

I know this seems simple, but the first step is to make sure your pages are tagged with the GA tracking code. Remember, this only works with the new ga.js tracking code.

<script type='text/javascript'>;
var pageTracker = _gat._getTracker("UA-XXXXX-X");
pageTracker._initData();
pageTracker._trackPageview();
</script>

Creating The Object

The first thing we need to do is create the object that we want to analyze. To create a new object we use a method name _createEventTracker(). We pass this method a value and that value is the name of the object we defined in the data model. Our object is called ‘Map’ so let’s use ‘Map’ in the name:

var mapEventTracker  = pageTracker._createEventTracker('Map');

When we look at the reporting interface we will see ‘Map’ in the Objects report. Pretty straight forward, huh?

This code must appear after your GA page tag. The reason is that the _createEvent Tracker() method is attached to the pageTracker object. In this example, I’m going to place it in the same block as the regular tracking code:

<script type='text/javascript'>
// Here’s the standard page tag stuff
var pageTracker = _gat._getTracker("UA-XXXXX-X");
pageTracker._initData();
pageTracker._trackPageview();

// Here is the new event object
var mapEventTracker  = pageTracker._createEventTracker('Map');
</script>

Tracking the Action

Now that we have an object, how do we track an action associated with that object? We add JavaScript to our page code when the action takes place. So, with our Maps example, we would add some code when the visitor clicks on the button to change the Map view type. Here’s how that code might look:

onClick="mapEventTracker._trackEvent('Change Map View', <label>, <value>);"

<label> and <value> should be replaced with one of the labels we identified in our data mode:

Map 5
Satellite 10
Hybrid 15
Street Level 20

What happens when a visitor clicks on a map button is that the code sends the action, label and value to GA and associates it with the map action we defined above. Now you can see how our data model really drives the implementation.

Tracking Multiple Objects

Ok, so here is something that’s pretty cool. Let’s say the map team wants to add two different maps to a single page. We can track both of them using the same map object. We would then differentiate what the visitor does using different labels. The actions would remain the same for both objects, but we’d have different labels.

A Final Note

I’d like to say that every implementation for event tracking can be different. It really depends on the business questions you need to answer and the structure of your pages. I think this post does a very good job of covering the basics, but your specific implementation will probably be a bit different… Unless you’re Google Maps. :)

As we’ll see in the next post, the new Event reports provide a logical structure for analyzing event data.

Event Tracking Pt. 2: Implementations is a post from: Analytics Talk by Justin Cutroni

Related posts:

1. Event Tracking Pt. 3: Reporting & Analysis
2. Tracking Clicks with GA Pt. 3: Advanced Implementation
3. Tracking Clicks with GA Pt. 1: About urchinTracker()

Event Tracking Pt. 1: Overview & Data Model
Event Tracking Pt. 2: Implementation

I wrote this post before having access to the new events reports. As a result, I don’t have any screen shots for you guys! Sorry I don’t have anything to show you guys, but I will try to explain as much as possible.

The new event reports section will have specific reports for objects, actions and labels. If you have not read my post on the event data model then I strongly suggest that you do so. The data model is the driving force behind the structure of the reports.

Event reports will let you see summary information at an Object level, action level and value level. Here’s an example using Google Maps. If we create a ‘Map’ object then we will get a unique count of how many times the map object has been created. We can then drill into that event and see the actions and values of those actions.

Map
|_ Click Map View
|_ Satellite
|_ Hybrid
|_ Map
|_ Traffic
|_ Street view

This drill-down functionality is very similar to the drill down that you can do with campaign tracking.

The interface will also show you the values of each label. Remember, Satellite, Hybrid, Map, Traffic and Street view, are all labels and they have an associated value. GA will total up the value and show a unique count of how many times each action happened, the total value and the average value.

This is fantastic information because we can now measure what people are doing on our media rich pages. We no longer need to rely on Average Time on Page to gauge the success of our content.

I know this is really high level, and I’m sorry I don’t have any screen shots, but I’ll try to get some soon. Hopefully you got a taste of what is possible with the event reporting.

Event Tracking Pt. 3: Reporting & Analysis is a post from: Analytics Talk by Justin Cutroni

Related posts:

1. Google Analytics Campaign Tracking Pt. 3: Reports and Analysis
2. GA On Site Search Pt. 2: Reporting & Usage
3. An Analysis of My Data