This reference describes the methods that you use for customizing how Google Analytics reporting works across domains, across different hosts, or within sub-directories of a website.
|
_cookiePathCopy(newPath)_getLinkerUrl(targetUrl,
useHash)_link(targetUrl, useHash)_linkByPost(formObject,
useHash)_setAllowHash(bool)_setAllowLinker(bool)_setCookiePath(newCookiePath)_setDomainName(newDomainName)_cookiePathCopy(newPath)
var pageTracker = _gat._getTracker("UA-12345-1");
pageTracker._trackPageview();
pageTracker._cookiePathCopy("/newSubDirectory/");
String newPath New path to store GATC cookies
under.
_getLinkerUrl(targetUrl, useHash)
_setDomainName() and _setAllowLinker() methods
to enable cross-domain user tracking specifically for iFrames and links
that open in a new window. This method returns a string of all the cookie
data from the initing link by appending it to the URL parameter. This can
then be passed on to a another site or iFrame.
pageTracker._getLinkerUrl("http://www.my-example-iframecontent.com/");
pageTracker._setAllowLinker(true);)
in order for link to work properly.
String targetUrl URL of target site to send
cookie values to.
String useHash Set to true for passing tracking
code variables by using the # anchortag separator rather than the default
? query string separator.
_link(targetUrl, useHash)
_setDomainName() and _setAllowLinker() methods
to enable cross-domain user tracking. The _link() method passes
the cookies from this site to another via URL parameters (HTTP GET). It
also changes the document.location and redirects the user to the new URL.
<a href="http://www.newsite.com" onclick="pageTracker._link('http://www.newsite.com');return false;">Go to our sister site</a>
pageTracker._setAllowLinker(true);)
in order for link to work properly.
String targetUrl URL of target site to send
cookie values to.
String useHash Set to true for passing tracking
code variables by using the # anchortag separator rather than the default
? query string separator.
_linkByPost(formObject, useHash)
_setDomainName() and _setAllowLinker() methods
to enable cross-domain user tracking. The _linkByPost() method
passes the cookies from the referring form to another site in a string
appended to the action value of the form (HTTP POST). This method is typically
used when tracking user behavior from one site to a 3rd-party shopping
cart site, but can also be used to send cookie data to other domains in
pop-ups or in iFrames.
<form action="http://www.shoppingcartsite.com/myService/formProcessor.php"
name="f" method="post" onsubmit="pageTracker._linkByPost(this)">
. . .
</form>
_setAllowLinker() must be set to true on the
destination web page in order for linking to work.
HTMLFormElement formObject Form object encapsulating
the POST request.
String useHash Set to true for passing tracking
code variables by using the # anchortag separator rather than the default
? query string separator.
_setAllowHash(bool)
true.
The domain hashing functionality in Google Analytics creates a hash value
from your domain, and uses this number to check cookie integrity for visitors.
If you have multiple sub-domains, such as example1.example.com and example2.example.com,
and you want to track user behavior across both of these sub-domains, you
would turn off domain hashing so that the cookie integrity check will not
reject a user cookie coming from one domain to another. Additionally, you
can turn this feature off to optimize per-page tracking performance.
Boolean true or false Default
value is true. If this parameter is set to true,
then domain hashing is enabled. Otherwise, domain hashing is disabled.
_setAllowLinker(bool)
false and linking
is disabled. See also _link(), _linkByPost(),
and _setDomainName() methods to enable cross-domain tracking.
Use the _setAllowLinker method on the target site, so that
the target site uses the cookie data in the URL parameter, instead of
the standard session logic.
pageTracker._setAllowLinker(true);
Boolean true or false Default
value is false. If this parameter is set to true,
then linker is enabled. Otherwise, domain linking is disabled.
_setCookiePath(newCookiePath)
Sets the new cookie path for your site. By default, Google Analytics sets the cookie path to the root level (/). In most situations, this is the appropriate option and works correctly with the tracking code you install on your website, blog, or corporate web directory. However, in a few cases where user access is restricted to only a sub-directory of a domain, this method can resolve tracking issues by setting a sub-directory as the default path for all tracking.
Typically, you would use this if your data is not being tracked and you subscribed to a blog service and only have access to your defined sub-directory, or if you are on a Corporate or University network and only have access to your home directory. In these cases, using a terminal slash is the recommended practice for defining the sub-directory.
pageTracker._setCookiePath("/~username/");
pageTracker._setCookiePath("/myBlogDirectory/");
String newCookiePath New cookie path to
set.
_setDomainName(newDomainName)
Sets the domain name for cookies. There are three modes to this method: ("auto" | "none" |
[domain]). By default, the method is set to auto,
which attempts to resolve the domain name based on the location object
in the DOM.
Set this method explicitly to your domain name if you want to track
visitor behavior across sub-domains in the same profile. For example,
if you have two sub-domains that you want to track in the same profile: petstore.example.com and fishstore.example.com,
you would set the domain name in each of these sites as follows:
pageTracker._setDomainName(".example.com");
As a best-practice method, you should use a leading "." in front of your domain name, as illustrated above. The leading period ensures that the same cookies will be read and written across all sub-domains of the specified domain.
If you do not use the leading "." when supplying a primary
domain—as in the example above—the browser automatically
sets the domain name with a leading period so that cookies are available
to petstore.example.com and fishstore.example.com.
However, if you want tracking across lower-level sub-domains:
dogs.petstore.example.com and cats.petstore.example.com, a leading period is required. If you do not use the leading
period in this type of setup, the cookies will not be available to the
lower-level domains of example.com (e.g. dogs.petstore.example.com).
For this reason, the most reliable sub-domain tracking is achieved
by consistently using the leading "." and in calling _setDomainName() in
all domains/sub-domains that you want to track as a single entity. This
is because the Analytics creates an encoded value of the domain specified
by the parameter passed into _setDomainName(), and if the
parameter is not identical across all domains, then different encoded
values will be created, causing conflicts and unexpected reporting behaviors.
Set this method to none in the following two situations:
_setAllowLinker() and _link
pageTracker._setDomainName("none");
String newDomainName New default domain
name to set.