Launch + AppMeasurement Clean Implementation Guide

Complete implementation reference for Adobe Analytics via Launch with AppMeasurement.

1. Extension Configuration

Adobe Analytics Extension

Full extension reference →

Link Tracking Settings

1b. Activity Map Deep Dive

Activity Map is built into AppMeasurement. When enabled, it automatically fires an s.tl() server call on every click — it's not just a visual heatmap overlay. Every click sends real data to your report suite.

What Activity Map sends on every click

Each click fires s.tl() with these context data variables:

// These go out automatically with every click — no rules needed
c.a.activitymap.page   = "Home Page"          // s.pageName value
c.a.activitymap.link   = "Sign Up Now"        // link text / aria-label
c.a.activitymap.region = "hero-section"       // parent container ID
c.a.activitymap.pageIDType = "1"              // page ID type

You can see these in the Adobe Debugger network tab on every click.

Extension settings that must be ON

Code settings (no checkbox in the UI)

s.trackInlineStats is NOT a checkbox in the Launch extension UI. It's a code-level setting. Two ways to set it depending on your access level:

Option A: Extension Custom Code (requires extension configuration access)

AA Extension > Configure Tracker Using Custom Code:

// Enable Activity Map click data collection
s.trackInlineStats = true;

// Tell AppMeasurement your domain so it knows internal vs exit links
s.linkInternalFilters = location.hostname;

Option B: Rule-based config (when extension configuration access is unavailable)

When the AA extension settings cannot be edited directly, create a dedicated config rule instead:

// Global config — runs at Library Loaded, order 1 (before all other rules)
// Alternative when extension custom code editor is not accessible
s.trackInlineStats = true;
s.linkInternalFilters = location.hostname;

What Activity Map tracks vs doesn't

Why clicks might not appear

1. s.trackInlineStats is false — the main toggle. Must be true.
2. Link tracking globally disabled — check "Enable Link Tracking" in extension settings.
3. The element isn't an <a> tag — Activity Map only auto-fires on elements AppMeasurement identifies as links. Use Rule 4 for everything else.
4. s.pageName isn't set — Activity Map needs a page name to associate the click. If your page view rule isn't firing first, Activity Map has no context.
5. The link text is empty — icon-only links with no text content, no aria-label, and no title won't produce a useful Activity Map entry.

Activity Map in Adobe Analytics reporting

Once enabled, these dimensions are available in Analysis Workspace:

You can also use the Activity Map browser overlay (separate browser extension from Adobe) to see a visual heatmap of clicks directly on the live page.

Activity Map + custom s.tl() rule = full coverage

2. Data Elements (DOM Scraping)

Every data element has ONE job. No data layer needed — everything comes from the URL, DOM, or cookies that already exist on the page.

Name format: lowercase.dot.notation

Data elements in Tags reference → | Core extension data element types →

Page-Level

User-Level

Campaign

Search

Environment

3. Page Type Detection

Custom Code data element: page.type

Infers page type from URL patterns and DOM elements. No data layer needed.

var path = location.pathname.toLowerCase();

if (path === '/' || path === '/index') return 'home';
if (path.includes('/product')) return 'product';
if (path.includes('/cart') || path.includes('/basket')) return 'cart';
if (path.includes('/checkout')) return 'checkout';
if (path.includes('/confirm') || path.includes('/thank')) return 'confirmation';
if (path.includes('/search')) return 'search';
if (path.includes('/login') || path.includes('/signin')) return 'login';
if (path.includes('/account') || path.includes('/profile')) return 'account';
if (path.includes('/blog') || path.includes('/article') || path.includes('/news')) return 'content';
if (path.includes('/faq') || path.includes('/help') || path.includes('/support')) return 'support';
if (path.includes('/contact')) return 'contact';
if (path.includes('/category') || path.includes('/collection')) return 'category';
if (document.querySelector('.error-page, .page-404, [data-error]')) return 'error';

return 'general';

4. User State Detection

Custom Code data element: user.authState

Looks for common DOM patterns indicating logged-in state.

// Check DOM for logged-in indicators
if (document.querySelector(
  '.logged-in, .authenticated, [data-logged-in], ' +
  '.user-menu, .account-nav, .my-account'
)) return 'authenticated';

// Check meta tags
var meta = document.querySelector('meta[name="user-status"]');
if (meta) return meta.content;

// Check cookies
if (document.cookie.includes('loggedIn=') ||
    document.cookie.includes('session=') ||
    document.cookie.includes('auth='))
  return 'authenticated';

return 'anonymous';

5. Search Term Detection

Custom Code data element: search.term

var params = new URLSearchParams(location.search);

return params.get('q')
  || params.get('query')
  || params.get('search')
  || params.get('s')
  || params.get('keyword')
  || (document.querySelector(
      'input[type="search"], input[name="q"], .search-input'
    ) || {}).value
  || '';

5b. Hybrid Data Layer + DOM Fallback Pattern

The most resilient implementation uses a layered approach: read from the data layer when available, fall back to DOM scraping when it's not. This eliminates the dependency on a perfectly populated data layer while still using it when present.

The Pattern

// Hybrid data element: always returns a value
// Priority: data layer → DOM → sensible default

var dl = window.digitalData || {};
var page = dl.page || {};

// Use data layer value if it exists and is non-empty
if (page.name && page.name.trim()) return page.name.trim();

// Fall back to DOM scraping
return document.title.replace(' | SiteName', '').trim();

Applied to Each Data Element

page.name (hybrid)

var dl = window.digitalData || {};
var page = dl.page || {};
return (page.name && page.name.trim())
  || (page.pageName && page.pageName.trim())
  || document.title.replace(/\s*[\|–—]\s*[^|–—]+$/, '').trim();

page.section (hybrid)

var dl = window.digitalData || {};
var page = dl.page || {};
return (page.section && page.section.trim())
  || (page.siteSection && page.siteSection.trim())
  || (page.category && page.category.trim())
  || location.pathname.split('/').filter(Boolean)[0] || 'home';

page.type (hybrid)

var dl = window.digitalData || {};
var page = dl.page || {};
if (page.type && page.type.trim()) return page.type.trim();
if (page.pageType && page.pageType.trim()) return page.pageType.trim();

// DOM/URL fallback
var path = location.pathname.toLowerCase();
if (path === '/') return 'home';
if (path.includes('/product')) return 'product';
if (path.includes('/cart')) return 'cart';
if (path.includes('/checkout')) return 'checkout';
if (path.includes('/search')) return 'search';
if (path.includes('/account')) return 'account';
if (path.includes('/blog') || path.includes('/article')) return 'content';
return 'general';

user.authState (hybrid)

var dl = window.digitalData || {};
var user = dl.user || {};
if (user.authState) return user.authState;
if (user.loginStatus) return user.loginStatus;
if (user.authenticated !== undefined) return user.authenticated ? 'authenticated' : 'anonymous';

// DOM fallback
if (document.querySelector('.logged-in, .authenticated, .user-menu, .my-account'))
  return 'authenticated';
return 'anonymous';

search.term (hybrid)

var dl = window.digitalData || {};
if (dl.search && dl.search.term) return dl.search.term;
if (dl.page && dl.page.searchTerm) return dl.page.searchTerm;

// URL/DOM fallback
var params = new URLSearchParams(location.search);
return params.get('q') || params.get('query') || params.get('search')
  || params.get('s') || params.get('keyword')
  || (document.querySelector('input[type="search"], input[name="q"]') || {}).value
  || '';

When to use which approach

6. Rules

Rule 1: Page View — All Pages

s.pageName  = %page.name%
s.channel   = %page.section%
s.pageType  = %page.type%
s.campaign  = %campaign.trackingCode%
s.eVar1     = %user.authState%
s.prop1     = %page.type%

Rule 2: Error Page

s.pageType = "errorPage"
s.events   = "event20"

Rule 3: Internal Search

s.eVar5  = %search.term%
s.prop5  = %search.term%
s.events = "event5"

7. Smart Click Tracking (No Data Attributes Needed)

One rule covers every clickable element. Reads whatever data exists on the element automatically.

Rule 4: Universal Click Tracker

var el = this;

// Walk up to find the actual clickable element (if we hit a child span/icon)
while (el && !el.matches('a, button, [role="button"], input[type="submit"]')) {
  el = el.parentElement;
}
if (!el) el = this;

// Grab the best label available
var label = el.getAttribute('aria-label')
  || el.getAttribute('title')
  || el.getAttribute('data-track-label')
  || el.getAttribute('data-analytics')
  || el.getAttribute('data-name')
  || el.textContent.trim().substring(0, 100)
  || el.getAttribute('alt')
  || el.value
  || 'unlabeled';

// Grab the region/section of the page
var region = '';
var parent = el.closest(
  '[id], [role="navigation"], [role="banner"], [role="main"], ' +
  '[role="contentinfo"], nav, header, footer, aside, main, [data-region]'
);
if (parent) {
  region = parent.getAttribute('data-region')
    || parent.getAttribute('id')
    || parent.getAttribute('role')
    || parent.tagName.toLowerCase();
}

// Grab the destination URL
var href = el.getAttribute('href') || '';

// Set the variables
s.eVar10 = label;
s.prop10 = label;
s.eVar11 = region || 'unknown';
s.prop11 = region || 'unknown';
s.eVar12 = href;
s.linkTrackVars = 'eVar10,prop10,eVar11,prop11,eVar12,events';
s.linkTrackEvents = 'event10';
s.events = 'event10';

// Fire the beacon right here — NOT as a separate Send Beacon action.
// s.tl() must be in the same code block so 'label' is available as the link name.
s.tl(this, 'o', label);

8. Form Tracking

Rule 5: Form Submit

// Scrape the form name from whatever exists
var formName = this.getAttribute('name')
  || this.getAttribute('id')
  || this.getAttribute('action')
  || (this.querySelector('[type="submit"]') || {}).textContent?.trim()
  || 'unknown form';

s.eVar13 = formName;
s.prop13 = formName;
s.linkTrackVars = 'eVar13,prop13,events';
s.linkTrackEvents = 'event11';
s.events = 'event11';

Then: Adobe Analytics > Send Beacon — s.tl(this, 'o', formName)

9. Data Attribute Pattern (If You Get Dev Support Later)

If developers eventually add data attributes to the HTML, you can target specific elements without changing Launch:

<!-- Any clickable element -->
<a href="/products" data-track-click data-track-label="Nav: Products">Products</a>
<button data-track-click data-track-label="Hero: Learn More">Learn More</button>

<!-- Any form -->
<form data-track-form="Contact Form" action="/submit">...</form>

The smart click rule (Rule 4) already checks for data-track-label and data-analytics attributes in its priority chain. So when devs add them, the tracking automatically gets more specific — no Launch changes needed.

10. CSS Selector Strategy

When targeting a specific element beyond the universal click tracker, use this priority for selectors:

11. Cleanup Checklist

1. Delete every data element that references %garbage% or doesn't exist
2. Delete every rule that references deleted data elements
3. Configure the AA extension settings (Activity Map ON, link tracking ON)
4. Create the clean data elements from the table above
5. Create the 5 rules
6. Build to staging
7. Validate with Adobe Debugger (see below)
8. Build to production

11b. Testing Data Elements in the Browser Console

Launch data elements can be tested directly in the browser console without publishing changes. These methods return the resolved value of any %data_element% in real time.

Method 1: _satellite.getVar()

// Returns the current resolved value of a data element
_satellite.getVar('page.name');
_satellite.getVar('page.type');
_satellite.getVar('user.authState');
_satellite.getVar('campaign.trackingCode');
_satellite.getVar('search.term');

Method 2: Dump all data elements at once

// List every data element name and its current value
var names = Object.keys(_satellite._container.dataElements || {});
names.forEach(function(name) {
  console.log(name + ': ' + _satellite.getVar(name));
});

Method 3: Test specific custom code logic

// Run the same code a custom code data element would run
// Useful for debugging fallback chains

// Example: test the hybrid page.name logic
(function() {
  var dl = window.digitalData || {};
  var page = dl.page || {};
  var result = (page.name && page.name.trim())
    || document.title.replace(/\s*[\|–—]\s*[^|–—]+$/, '').trim();
  console.log('page.name would resolve to:', result);
  console.log('Source:', (page.name && page.name.trim()) ? 'data layer' : 'DOM fallback');
})();

Method 4: Check the data layer object directly

// See what the data layer contains (or if it exists at all)
console.log('digitalData:', window.digitalData);
console.log('dataLayer:', window.dataLayer);
console.log('utag_data:', window.utag_data);

// Deep inspect a specific path
console.table(window.digitalData && window.digitalData.page);

Method 5: Validate the s object after a page view fires

// After the page loads and the page view rule fires,
// inspect what AppMeasurement actually sent
console.log('pageName:', s.pageName);
console.log('channel:', s.channel);
console.log('campaign:', s.campaign);
console.log('eVar1:', s.eVar1);
console.log('events:', s.events);

// Or dump all populated props and eVars
for (var i = 1; i <= 75; i++) {
  if (s['prop' + i]) console.log('prop' + i + ': ' + s['prop' + i]);
}
for (var i = 1; i <= 250; i++) {
  if (s['eVar' + i]) console.log('eVar' + i + ': ' + s['eVar' + i]);
}

Method 6: Enable Launch debug logging

// Enables verbose console output for all Launch rule evaluations,
// data element resolutions, and beacon calls
_satellite.setDebug(true);

// Disable when done
_satellite.setDebug(false);

Method 7: Test a click tracking rule manually

// Simulate what the universal click tracker would capture
// for a specific element — without actually firing a beacon
var el = document.querySelector('#sign-up-btn'); // target element

var label = el.getAttribute('aria-label')
  || el.getAttribute('title')
  || el.textContent.trim().substring(0, 100)
  || 'unlabeled';

var parent = el.closest('[id], nav, header, footer, main, aside');
var region = parent
  ? (parent.getAttribute('id') || parent.tagName.toLowerCase())
  : 'unknown';

console.log('Label (eVar10):', label);
console.log('Region (eVar11):', region);
console.log('Href (eVar12):', el.getAttribute('href') || 'none');

12. Validation

Using the AA Debugger or Adobe Experience Platform Debugger extension:

13. Full Coverage Matrix

14. API Reference

Variable Mapping Summary

Beacon Types

Complete variable reference →