A power user of WebTrends recently told me that, “With WebTrends, you are only limited by your imagination.”  For our advanced users, this is true.  They see the power of the platform, get in there, and access all sorts of custom controls and configurations made available to them. However, exposing these power features to our power users has come at a cost, the overall user experience.  When I joined the WebTrends team, my mandate was to dramatically improve the user experience of our products for all users. I am proud to announce the first manifestation of this initiative.

Previous Tag Builder - Version 2.2

Enter Tag Builder – the starting point for our User Experience (UX) transformation.  Tag Builder is a great power user mini-app.  It allows a user to quickly put together a powerful custom javascript tag for visitor/behavior tracking.  These tags work for both the Analytics and Warehouse platforms and even includes options for Ad Director and Quantcast tracking (2.2 release feature) all within one custom javascript file. Tag Builder, because of its small size, allowed us to do a complete overhaul on the user interface while keeping the engine that builds the actual tag on the backend the same.  We even included a link to the 2.2 version of TagBuilder so users who rely on Tag Builder can access the previous version during the transition so they can compare the javascript files for their own curiosity and quality assurance.

New Tag Builder - Version 3.0

The next four articles will walk through the detailed changes manifested in the new Tag Builder, the methodologies that led up to them, and what this means for the larger WebTrends product line.

Try out the new WebTrends Tag Builder yourself. And let us know what you think.

Flash tracking as with AJAX is done through calls to dcsMultiTrack. However because a Flash applet file (.swf) is embedded into a page as a self contained object this means we must use a different method to make calls to other elements such as the logging script within the page.

We can use any event in Flash to trigger a dcsMultiTrack call; video completions, slide views, loading percentage indicators, clicks, drags, drops and more. The most common or at least traditional method for calling dcsMultiTrack within Flash uses the getURL function:

on(release){
getURL(”javascript:dcsMultiTrack(’parameter1′,’value1′,’parameter2′,’value2′);”);
}

This code would be added to each button that needs to be tracked. If you’re smart you won’t want to rewrite the multiTrack onto every event handler call for every button across your site. It makes sense as with did with AJAX to use a more modular approach. Taking the getURL method above and placing the call into its own ActionScript function, then calls to the event handlers can also be passed along with parameters to this function.

function trackEvent(value1,value2){
getURL(”javascript:dcsMultiTrack(’parameter1′,’”+value1+”‘,’parameter2′, ‘”+value1+”‘);”);
}

An alternate to getURL is the externalInterface method:
import flash.external.ExternalInterface;

function trackEvent(value1,value2):Void
{
If (ExternalInterface.available)
{
ExternalInterface.call(”dcsMultiTrack”,’Parameter1′,value1,’parameter2′,valu e2);
}
}

Where scalability may be a factor the externalInterface method is the best probably the best choice. In addition to being scalable, externalInterface is the new “best practice” method for page/Flash object interactions. It allows data to be passed in and out of the Flash object (a getURL is a static one-way command). Because of the added flexibility, this method will allow new interactions to happen as they are developed.

Should the externalinterface method be attached to all event handlers enabling you to collect information on any and every interaction? Or prehaps limited only to duistinct content loads/views within the applet? And what should you be passing as parameters? Why not join us to discuss this at Engage 2009 in our Workgroup. Look forward to seeing you there.

I’ve been in the software industry for over 20 years and in that time I have seen plenty of term confusion and misuse.  But it’s hard for me to remember a time when I saw so much of it from a single space.  Let’s clear the air on a couple of definitions (for now), beginning with the liberal use of the term multivariate.

Regardless of the terms, there are really two fundamental forms of testing and optimization in our space: split tests, as I refer to them, and multivariate.  Split tests, a.k.a. A/B tests or A/B/n tests, apply when you have a small number of variables and values.  For instance a single variable, such as an image, may have two values, Image A and Image B.  This most basic example is where the term A/B test comes from.  Add in Image C, Image D and Image E, and you can see why the A/B/n shorthand is used.  In these instances the number of values is low enough to permit a large number of trials to be performed on each, providing us with a clear statistical winner with a reasonably sized population of trials.

Now let’s throw in another variable, such as a text block.  You might have two versions of the text to go along with two versions of the image, making four combinations.  This is where the confusion enters in.  Some vendors have gotten into an annoying habit of calling this multivariate.  It’s not.  You can use the exact same split test approach as before – it just so happens there are two variables involved.  I like to call this multi-variable split tests, but frankly I don’t care what we call it, so long as it’s not confused with multivariate.

So what is multivariate optimization?  It’s a form of statistical variance analysis.  The Taguchi methods (named after its inventor Genichi Taguchi) is one form of multivariate statistics reportedly used in several behavioral targeting, testing and ad optimization solutions today.  Where multivariate statistics come into play is when the number of variable/value combinations is so large that it prohibits more than a small number of trials being run against a single combination of values (i.e. it would be too time consuming or too costly).  Multivariate statistics permit us to infer, statistically, the singular values and/or combinations that lead to the desired outcome (e.g. conversions) based on a relatively small population of trials.

Now that we have that cleared up, let’s move onto the term “portfolio” as it applies to PPC campaigns. Back in the ‘70’s and 80’s, Harry Markowitz published his works on Modern Portfolio Theory (MPT).  His work earned him the Nobel Memorial Prize for Economic Sciences in 1990. Essentially MPT provides the body of mathematics used to create diversified investment strategies, and in so doing providing the greatest possible return within a given risk tolerance (notwithstanding global economic calamities, that is).  Or conversely, the lowest amount of risk for a desired return.  It’s all on Wikipedia, so you can read all about it there.

More recently some really smart people from Efficient Frontier, Inceptor (RIP) and WebTrends applied some of the principles of MPT towards the problem of optimizing large-scale PPC campaigns.  In fact Efficient Frontier derives its name from one of the main concepts of MPT.  It is also how the term “portfolio” came to be used in the context of search marketing.  Today I’m only aware of three vendors that use MPT-style mathematics in their PPC optimization solutions: Efficient Frontier, eSearchVision (I think) and WebTrends.  If there are others, please comment below and let me know.

So now enter the confusion.  Several vendors advertise “portfolio-based bid management” capabilities.  What is meant by this is that you can apply a bid rule against a group of keywords.  The term portfolio, in this instance, is used as an English synonym to group or collection.  Grammatically accurate?  Yes.  Intentionally designed to mislead?  Absolutely.

Of course vendors get away with this because the detailed understanding of these technologies is locked in the heads of a relatively small number of people.  But hopefully they are influential people who have a belief in transparency and truth in advertising.  So if you’re one of those people, please help educate the market, starting with me.  If you see errors in fact or have differences in opinion from my comments or in WebTrends’ messages, let’s hear it.

Silverlight and JavaScript play nice together, so making manual requests for each interaction you want to track via DCSMultiTrack should not be a problem, though it will be time consuming to go through and add all these calls yourself.

The interaction between Silverlight 2.0 and WebTrends logging has been simplified by using a custom class developed by WebTrends. All you need do is simply add the class to your project by either including it in your current file, or by adding a new Silverlight class library.

The class is called “DcsMultiTrack” and lives in the namespace “WebTrends”. This code is essentially a tunnel between the Silverlight and the JavaScript function “dcsMultiTrack”. The “Send” method is used with the same name / value pairs as you would if making a standard JavaScript call to dcsMultiTrack. Here is an example:

DcsMultiTrack multitrack = new DcsMultiTrack();
multitrack.Send(”WT.ti”, “PageTitle”, “dcsuri”, “/silverlightapp/search_button”);

The Send call will not fail if the application is embedded on a page where WebTrends tags are not available. And… here is the class code:

namespace WebTrends
{
using System;
using System.Net;
using System.Windows;
using System.Windows.Browser;

///
/// WebTrends Tracking function for Silverlight
///
public class DcsMultiTrack
{
///
/// Private value
///
private static bool hasDcsMultiTrack = false;

///
/// Initializes a new instance of the DcsMultiTrack class
///
public DcsMultiTrack()
{
if (!hasDcsMultiTrack)
{
try
{
string typeOfFunction = (string)HtmlPage.Window.Eval(”typeof(dcsMultiTrack)”);
hasDcsMultiTrack = (typeOfFunction == “function”);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
}
}
}

///
/// Gets or sets a value indicating whether or not dcsMultiTrack exists in JavaScript
///
public bool LoggingEnabled
{
get { return hasDcsMultiTrack; }
set { }
}

///
/// Issue log request to WebTrends
///
///
Name/value pairs eg:(”WT.ti”, “title”, “dcsuri”, “/silverlight_app/button1″) /// multiTrack.call(”WT.ti”, “title”, “dcsuri”, “/silverlight_app/button1″)
public void Send(params object[] args)
{
if (HtmlPage.IsEnabled && hasDcsMultiTrack && (args.Length % 2 == 0))
{
try
{
HtmlPage.Window.Invoke(”dcsMultiTrack”, args);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
}
}
}
}
}

Simple right? Any questions? Well there is one blringly obvious question; When do I make my Send call? In call these Rich Media Technologys yes we can make logging requests but when? And what do we put in them? What constitutes as a page view in an interface with no pages. This is a question we will focus on in our Workgroup.

Accessing the logging script and making calls to DCSMultiTrack from AJAX should be very simple since you are likely using JavaScript already to handle user interactions, build your XHTML controls, and utilize XMLHttpRequest. Even if you are using a different scripting language such as VBScript you can still make a call to a JavaScript function in much the same way you would from within JavaScript.

If you wanted to make the deployment of your AJAX ‘tagging’ more efficient rather than add a call to every object action you want to track you may consider adding it into your event handler function to your AJAX application that will automatically make calls to DCSMultiTrack when triggered:

Button1.onclick = updateData()
…
function updateData(event, param) {
var myurl = www.domain.com/service/ajax.aspx

http.open(”GET”, myurl + “?id=” + escape(param), true);
http.onreadystatechange = useHttpResponse();
DCSMultiTrack(”DCSURI”,”/ajax/menu/”+event.target+”/”event.type,”DCSext.param”,”param”)
http.send(null);

}

Here I have used the example of on click event handler but it could just add the call within a wrapped up function and attach this to a rootElement event handler. The issue there then becomes that you will be tracking all user interactions so what do you start passing as page URL’s and other parameters just to say represent a mouse drag.

Should the handler be attached to all events enabling you to collect information on any and every interaction? Or prehaps limited only to duistinct content loads/views within the applet? And what should you be passing as parameters? Why not join us to discuss this at Engage 2009 in our Workgroup.

It is sometimes the case that from some technologies we are unable to make a call to JavaScript or in some environments even execute JavaScript. One example of this would be RSS feeds where sites content or some other kind of informational stream is downloaded directly from a web server into desktop or third party web based aggregator. We will need to combine a variety of different technologies and reporting approaches to give us encompassing view of RSS utilization, from subscription to consumption.
What we can easily track are clicks on the RSS feed or subscribe link. If a visitor clicks on the link we will want to count that as a subscription using DCSMultiTrack:

This dcsMultiTrack call will populate both of the WebTrends 8.5 + out of the box RSS subscription reports.
But once people have subscribed are they reading the feeds? A “Feed Read” is a request for the RSS file on the server. Since it is impossible to tag an RSS file with JavaScript like we might a web page, the collection of this data will need to be implemented at the server side, sending a logging request directly to the SDC from your own web server. Since we don’t have the WebTrends JavaScript around to build and format this request for us we will have to do it our selves but hopefully is should be something similar to this:

“http://SDC DOMAIN/DCS ID/dcs.gif?dcsdat=POSIX TIME STAMP&dcssip=THE DOMAIN SERVING RSS FEED&dcsuri=PATH OF RSS FEED&dcsua=USER AGENT&dcscfg=1&WT.dl=10&WT.rss_f=TITLE OF RSS FEED&WT.rss_ev=f&WT.ti=TITLE OF RSS FEED&OPTIONAL QUERY STRING

The other standard measure is “Article Requests”; the number of clickthroughs a RSS article or item receives. The tagging of these items is similar to how campaign links are tagged with WT.mc_id. An example of how we might want to format the RSS feed tag link would be:

HTTP://THE ARTICLE URL&WT.rss_f=TITLE OF RSS FEED&WT.rss_a=ARTICLE NAME&WT.rss_ev=a

If we wanted to consider a RSS feed a campaign channel we could also add a WT.mc_id too:

HTTP://THE ARTICLE URL&WT.rss_f=TITLE OF RSS FEED&WT.rss_a=ARTICLE NAME&WT.rss_ev=a&WT.mc_id=CAMPAIGN ID

Moving beyond the out of the box RRS reporting can we track the number of times a post or item is viewed? While most portal based aggregators do not support the viewing of images, web based personal aggregators and desktop based aggregators do. Using an image calls embedded in the items we can get simple item view information similar to the noscript tags used in standard pages. As is the case with tracking feed requests, the image call needed to track this data will need to be generated manually. The format of the generated image request should be something like:

“http://SDC DOMAIN/DCS ID/dcs.gif?dcssip=THE DOMAIN SERVING RSS FEED&dcsuri=PATH OF RSS FEED&dcsua=USER AGENT&dcscfg=1&WT.dl=10&WT.rss_f=TITLE OF RSS FEED&WT.rss_ev=av&WT.ti=TITLE OF RSS FEED&OPTIONAL QUERY STRING”

Note: WT.rss_ev state “av” is a custom parameter, It is not officiall an WebTrends parameter.
It is very important that the image call occur in the body or content of the request. This will ensure that the request will fire when the item is viewed. Putting it in another section of the XML may result in the image not being rendered.
What about tracking activity from RSS aggregators? The neat thing about most portal and web based personal aggregators is that they actually pass the number of subscribers in the agent string.

Here are a few common examples:

Feedfetcher-Google; (+http://www.google.com/feedfetcher.html; 4 subscribers; feed-id=124155534636)

NewsGatorOnline/2.0 (http://www.newsgator.com; 20 subscribers)

Bloglines/2.0 (http://www.bloglines.com; 81 subscribers)

ThePort Web/1.0; subscribers 1LiveJournal.com (webmaster@livejournal.com; for your url/; 1 readers)

YahooFeedSeeker/1.0 (compatible; Mozilla 4.0; MSIE 5.5; http://my.yahoo.com/s/publishers.html; users 2; views 169)

As before, we can pull this data into WebTrends using server side code. This process would occur during the “Tracking Feed Reads” process described above. You would simply need to replace the code under “preprocesses user data to remove junk data at the end of the string” with this more functional code. It is very important that this code IS NOT added to the Article View functionality. Adding it to that code may cause the subscriber numbers to be reported incorrectly.

This of course is all a lot of work for your developers, and would certainly be considered advanced tagging. Are there any alternatives? You could use log files, but you would lose the rich information with tagging that you are able to ascertain about each Feed being accessed and read.

Another alternate to both web logs and server side tagging would be WebTrends partner Atomic Labs. Product; Pion. It use passive network data capture to listen to customer interactions without the need for page tags or server logs. It can strip out information from web documents including RSS feeds as they are requested by visitors and process these into WebTrends parameters in SDC logs. You can find out more about this in Engage 2009 Workgroup Session.

With broadband now common place in the home, Web Developers are using more and more Rich Media content in their websites. The sinus and flowing interfaces of applications built in technologies such as AJAX, Flash, and SilverLight are replacing ‘blocky’ single state HTML pages. How do we track visitors in these new technologies, and how will we redefine the page view to reflect these fluid interactions?

Part I: Tracking

Let us first address the fundamental problem of issuing logging requests from the client side to our SDC server (web server log files will be no use to us here) from within these technologies, as it is perhaps the most straight forward of the two questions we will address here.

The gap we must bridge is that between our application and the WebTrends logging JavaScript, our end goal being a call to the DCSMultiTrack function… used to trigger subsequent logging requests to an SDC server so that we might capture events that occur after the initial logging request that is made by the script when a page is loaded. These include client-side mouse events (clicks on links), form events, and interaction with embedded objects such as our rich media applications.

The function takes paired values as arguments:

	dcsMultiTrack('name1','value1','name2','value2',...)

All arguments are JavaScript strings which must be enclosed in quotes. The first part of the pair is the parameter name which must be of the form ‘object.name’ where ‘object’ is the name of one of three pre-defined custom objects: WT, DCS, DCSext. And ‘name’ – The property name of the custom object (for WT and DCS these are reserved names). The second part of the pair is the parameter value.
Note the all initial parameter assignments from the initial page load remain unchanged in the triggered request unless overridden by parameter values passed to DCSMultiTrack.

DCSMultiTrack will act as a bridge for us between our Web technology and JavaScript since most client side languages can utilize or make calls to JavaScript functions directly or indirectly. What we record with these DCSMultiTrack requests however we must define ourselves. How do we designate page views and parameter values that will give us a wide enough data set to fully understand how our visitors navigate these technologies.

However it is sometimes the case that from some technologies we are unable to make a call to JavaScript or in some environments even execute JavaScript. One example of this would be RSS feeds where sites content or some other kind of informational stream is downloaded directly from a web server into desktop or third party web based aggregator. We will need to combine a variety of different technologies and reporting approaches to give us encompassing view of RSS utilization, from subscription to consumption.

When do I make my Send call? In call these Rich Media Technologys yes we can make logging requests but when? And what do we put in them? What consitutes as a page view in an interface with no pages. This is a question we will attempt to answer at our Engage 09 Workgroup.