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

2. Activity Map

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

3. Data Elements

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

4. 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';

5. 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';

6. 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
  || '';

7. Common Data Elements — Best Practices

Reference patterns for frequently tracked values. Each example shows the recommended approach with fallback chains, proper return statements, and inline documentation.

Search Terms (multiple types)

Internal site search

// Data element: search.term
// Captures the search query from URL parameters or the search input field.
// Common parameter names vary by platform — check all known patterns.
var params = new URLSearchParams(location.search);

// Check URL parameters (most common — search results pages use query strings)
var term = params.get('q')         // Google-style
  || params.get('query')     // Explicit
  || params.get('search')    // Generic
  || params.get('s')         // WordPress default
  || params.get('keyword')   // E-commerce
  || params.get('searchTerm') // CMS platforms
  || params.get('k')         // Shortened
  || '';

// If no URL param, check the search input field value (SPA or pre-submit)
if (!term) {
  var input = document.querySelector(
    'input[type="search"], input[name="q"], input[name="query"], ' +
    'input[name="search"], .search-input, [data-search-input]'
  );
  if (input && input.value) term = input.value;
}

// Clean: lowercase, trim, limit length for reporting
return term ? term.trim().toLowerCase().substring(0, 255) : '';

Search results count

// Data element: search.resultsCount
// Captures how many results were returned. Useful for zero-results analysis.
var el = document.querySelector(
  '[data-results-count], [data-total-results], ' +
  '.results-count, .search-results-count, .hits-count'
);
if (el) {
  var count = el.getAttribute('data-results-count')
    || el.getAttribute('data-total-results')
    || el.textContent.replace(/[^0-9]/g, '');
  return count || '0';
}
return '';

Search type (to differentiate search contexts)

// Data element: search.type
// Identifies WHERE the search originated — global nav, category filter, etc.
var path = location.pathname.toLowerCase();
var params = new URLSearchParams(location.search);

if (params.get('category') || params.get('cat')) return 'filtered';
if (path.includes('/search')) return 'site search';
if (params.get('q') || params.get('query')) return 'site search';
if (document.querySelector('.autocomplete-results:not(:empty)')) return 'predictive';
return '';

Site Sections (hierarchical)

Primary section (level 1)

// Data element: site.section
// First directory segment of the URL path. Maps to s.channel.
var segments = location.pathname.split('/').filter(Boolean);
return segments[0] || 'home';

Sub-section (level 2)

// Data element: site.subSection
// Second directory segment. Useful for prop/eVar hierarchy reporting.
var segments = location.pathname.split('/').filter(Boolean);
return segments[1] || '';

Full breadcrumb path

// Data element: site.hierarchy
// Full path as a delimited string. Maps to s.hier1 or a prop.
// Produces: "products|electronics|headphones"
var segments = location.pathname.split('/').filter(Boolean);
return segments.join('|') || 'home';

Section from DOM (breadcrumb or nav)

// Data element: site.sectionFromDOM
// Falls back to reading the breadcrumb or active nav element when
// the URL structure doesn't reflect the true site section.
var breadcrumb = document.querySelector(
  'nav[aria-label="breadcrumb"] a, .breadcrumb a, ' +
  '.breadcrumbs a, [data-breadcrumb] a'
);
if (breadcrumb) return breadcrumb.textContent.trim();

// Active nav item
var activeNav = document.querySelector(
  'nav .active, nav [aria-current="page"], ' +
  '.nav-item.active, .navigation .current'
);
if (activeNav) return activeNav.textContent.trim();

// URL fallback
return location.pathname.split('/').filter(Boolean)[0] || 'home';

Customer Status

Customer type / tier

// Data element: customer.type
// Identifies the customer segment: new, returning, member, VIP, etc.
// Priority: data layer → DOM indicators → cookie
var dl = window.digitalData || {};
var user = dl.user || dl.customer || {};

// Data layer (most reliable if populated)
if (user.type) return user.type;
if (user.segment) return user.segment;
if (user.tier) return user.tier;
if (user.customerType) return user.customerType;

// DOM indicators (class names or data attributes on body/container)
var body = document.body;
if (body.classList.contains('vip') || body.classList.contains('premium')) return 'premium';
if (body.classList.contains('member')) return 'member';
if (body.getAttribute('data-customer-type')) return body.getAttribute('data-customer-type');

// Cookie-based (if the platform sets a customer segment cookie)
var cookies = document.cookie.split('; ');
for (var i = 0; i < cookies.length; i++) {
  if (cookies[i].startsWith('customer_type=')) return cookies[i].split('=')[1];
  if (cookies[i].startsWith('user_segment=')) return cookies[i].split('=')[1];
}

return 'unknown';

Login Status

Authentication state

// Data element: user.loginStatus
// Determines logged-in vs logged-out state from available signals.
// Priority: data layer → DOM classes → meta tags → cookies
var dl = window.digitalData || {};
var user = dl.user || {};

// Data layer
if (user.authState) return user.authState;
if (user.loginStatus) return user.loginStatus;
if (user.isLoggedIn === true) return 'logged in';
if (user.isLoggedIn === false) return 'logged out';

// DOM: look for elements that only render for authenticated users
if (document.querySelector(
  '.logged-in, .authenticated, [data-logged-in], ' +
  '.user-menu, .account-nav, .my-account, ' +
  '[data-auth-state="authenticated"], .user-avatar'
)) return 'logged in';

// Meta tags (some platforms set these server-side)
var meta = document.querySelector(
  'meta[name="user-status"], meta[name="login-status"], meta[name="auth-state"]'
);
if (meta && meta.content) return meta.content;

// Cookies (common auth indicators)
var c = document.cookie;
if (c.includes('loggedIn=true') || c.includes('auth=1') ||
    c.includes('is_authenticated=1')) return 'logged in';

return 'logged out';

ECID (Experience Cloud ID)

Retrieve the ECID from the Visitor API

// Data element: visitor.ecid
// The ECID (Marketing Cloud Visitor ID) is set by the Adobe Visitor ID Service.
// It is available via the Visitor API object after the service initializes.

// Method 1: Visitor API (standard — works when ECID Service extension is installed)
if (typeof Visitor !== 'undefined') {
  var visitor = Visitor.getInstance('INSERT-ORG-ID-HERE@AdobeOrg');
  if (visitor && visitor.getMarketingCloudVisitorID) {
    var ecid = visitor.getMarketingCloudVisitorID();
    if (ecid) return ecid;
  }
}

// Method 2: Read from the AMCV cookie directly (fallback)
// The AMCV cookie contains the ECID in a pipe-delimited format.
var cookies = document.cookie.split('; ');
for (var i = 0; i < cookies.length; i++) {
  if (cookies[i].startsWith('AMCV_')) {
    var val = decodeURIComponent(cookies[i].split('=').slice(1).join('='));
    var match = val.match(/MCMID\|(\d+)/);
    if (match) return match[1];
  }
}

return '';

Campaign / Traffic Source

Campaign tracking code (multi-parameter)

// Data element: campaign.code
// Checks multiple common campaign parameters.
// Priority order matters — cid is the Adobe standard, utm_campaign is Google.
var params = new URLSearchParams(location.search);

return params.get('cid')            // Adobe standard
  || params.get('s_cid')          // Adobe alternate
  || params.get('utm_campaign')   // Google
  || params.get('campaign')       // Generic
  || params.get('promo')          // Promotional
  || '';

Traffic source / medium

// Data element: traffic.source
// Identifies how the visitor arrived: organic, paid, direct, social, email, referral.
var params = new URLSearchParams(location.search);
var ref = document.referrer;

// Paid campaigns (has tracking parameters)
if (params.get('utm_medium')) return params.get('utm_medium');
if (params.get('cid') || params.get('gclid') || params.get('fbclid')) return 'paid';

// No referrer = direct
if (!ref) return 'direct';

// Search engines
if (/google\.|bing\.|yahoo\.|duckduckgo\.|baidu\./.test(ref)) return 'organic';

// Social
if (/facebook\.|twitter\.|linkedin\.|instagram\.|tiktok\.|youtube\./.test(ref)) return 'social';

// Email (common referrer patterns)
if (/mail\.|outlook\.|gmail\./.test(ref)) return 'email';

// Same domain = internal (exclude from reporting)
if (ref.includes(location.hostname)) return 'internal';

return 'referral';

Additional useful elements

Page load time (performance)

// Data element: performance.pageLoadTime
// Captures page load duration in milliseconds using the Performance API.
// Best used with a Window Loaded event (not Library Loaded) so timing is complete.
var nav = performance.getEntriesByType('navigation')[0];
if (nav) return Math.round(nav.loadEventEnd - nav.startTime).toString();
return '';

Viewport / device category

// Data element: device.category
// Simple responsive breakpoint detection — matches CSS media query logic.
var w = window.innerWidth;
if (w < 768) return 'mobile';
if (w < 1024) return 'tablet';
return 'desktop';

Content group (for editorial/blog sites)

// Data element: content.category
// Reads the content category from meta tags, schema markup, or DOM.
var meta = document.querySelector(
  'meta[property="article:section"], meta[name="category"], ' +
  'meta[name="content-type"], [data-content-category]'
);
if (meta) return meta.content || meta.getAttribute('data-content-category');

// Schema.org breadcrumb
var schema = document.querySelector('[itemtype*="BreadcrumbList"] [itemprop="name"]');
if (schema) return schema.textContent.trim();

// URL segment fallback
var segments = location.pathname.split('/').filter(Boolean);
return segments[0] || '';

8. Hybrid Data Layer + DOM Fallback

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 || {};
// Data layer first, then DOM fallback.
// The regex strips common title suffixes like " | Site Name" or " — Brand"
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 — same checks as the DOM-only version
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';

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 — check common 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';

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"], .search-input') || {}).value
  || '';

When to use which approach

9. Rules

Rule 1: Page View — All Pages

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

Rule 2: Error Page (Set Variables Only)

// Set error-specific variables BEFORE the page view rule fires.
// Rule 1 (order 50) handles the s.t() call — do NOT add Send Beacon here.
// Adding s.t() here would cause two page view beacons on error pages.
s.pageType = "errorPage"
s.events   = "event20"

Rule 3: Internal Search (Set Variables Only)

// Set search-specific variables BEFORE the page view rule fires.
// Rule 1 (order 50) handles the s.t() call — do NOT add Send Beacon here.
s.eVar5  = %search.term%
s.prop5  = %search.term%
s.events = "event5"

10. Click Tracking

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

Rule 4: Universal Click Tracker

// Launch's Core > Click event binds 'this' to the clicked DOM element.
// No addEventListener or handler function is needed — Launch provides the context.
// 'this' might be a child element (e.g., a <span> or <svg> icon inside
// a <button>), so we walk up the DOM tree to find the actual
// interactive parent element.
var el = this;

// Walk up to find the actual clickable element (button, link, etc.)
// Stops when it finds an element matching one of the interactive selectors.
while (el && !el.matches('a, button, [role="button"], input[type="submit"]')) {
  el = el.parentElement;
}
// If no matching parent was found, fall back to the original clicked element.
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 tracking variables for this click.
// eVars persist across the visit; props are hit-level only.
// Using both gives flexibility in reporting.
s.eVar10 = label;    // What was clicked (persists)
s.prop10 = label;    // What was clicked (this hit only)
s.eVar11 = region || 'unknown';  // Where on the page
s.prop11 = region || 'unknown';  // Where on the page (hit)
s.eVar12 = href;     // Destination URL (if applicable)

// linkTrackVars: MUST list every variable to include in the s.tl() call.
// Any variable not listed here will be silently excluded from the beacon.
s.linkTrackVars = 'eVar10,prop10,eVar11,prop11,eVar12,events';

// linkTrackEvents: MUST list every event to include.
s.linkTrackEvents = 'event10';
s.events = 'event10';

// Fire the beacon. Per Adobe docs, the first argument controls delay:
//   this  = wait up to 500ms for the beacon before allowing navigation
//   true  = do not wait (fire and forget)
// Using 'this' to ensure the beacon completes before any page navigation.
s.tl(this, 'o', label);

11. Form Tracking

Rule 5: Form Submit

// In an Adobe Analytics Custom Code action triggered by a Core > Form Submission
// event, 'this' refers to the <form> element that was submitted.
// Scrape the form name from whatever attributes exist on the element.
// Priority: name attr → id attr → action attr → submit button text → fallback
var formName = this.getAttribute('name')
  || this.getAttribute('id')
  || this.getAttribute('action')
  || (this.querySelector('[type="submit"]') || {}).textContent?.trim()
  || 'unknown form';

// Set the variables that will be sent with the beacon.
// eVar13 persists across the visit; prop13 is hit-level only.
s.eVar13 = formName;
s.prop13 = formName;

// linkTrackVars tells AppMeasurement which variables to include
// in this s.tl() call. Without this, the eVars/props are ignored.
s.linkTrackVars = 'eVar13,prop13,events';
s.linkTrackEvents = 'event11';
s.events = 'event11';

// Fire the beacon directly from this code block.
// 'this' is the form element — passing it as the first arg tells
// AppMeasurement to wait up to 500ms for the beacon before navigating.
// Do NOT use a separate Send Beacon action — it cannot access
// the formName variable defined above.
s.tl(this, 'o', formName);

12. Data Attribute Pattern

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.

13. CSS Selector Strategy

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

14. 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 rules (5 core rules + 1 global config rule if using Option B)
6. Build to staging
7. Validate with Adobe Debugger (see below)
8. Build to production

15. Console Testing

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

// Same priority chain as Rule 4's actual code
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';

// Same region detection as Rule 4
var parent = el.closest(
  '[id], [role="navigation"], [role="banner"], [role="main"], ' +
  '[role="contentinfo"], nav, header, footer, aside, main'
);
var region = parent
  ? (parent.getAttribute('id') || parent.getAttribute('role') || parent.tagName.toLowerCase())
  : 'unknown';

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

16. Validation

Using the AA Debugger or Adobe Experience Platform Debugger extension:

17. Coverage Matrix

18. API Reference

Variable Mapping Summary

Beacon Types

Complete variable reference →