Tealium Learning Center

Purpose The Tealium class serves as the main API entry point for all additional modules. Almost all API calls will go through the Tealium class. Supported Platforms iOS tvOS watchOS macOS Installation Included with the TealiumCore framework CocoaPods pod 'tealium-swift/TealiumCore' import TealiumSwift Carthage TealiumCore.framework import TealiumCore Public API Tealium Constructor for a new Tealium object. Tealium(config: TealiumConfig) Parameters Type Description config TealiumConfig object Initialize the Tealium object with a TealiumConfig object containing your account details. let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "your_environment") let tealium = Tealium(config: config) Optionally, you may pass a completion closure block. If you need to use the RemoteCommands feature, or need to send tracking calls immediately after initialization, you should do so in the completion block. Tealium(config: TealiumConfig, completion: Closure) Parameters Type Description config TealiumConfig object Initialize the Tealium object with a TealiumConfig object containing your account details. completion Closure to be called on init completion ()-> Void )? let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "your_environment") let completionHandler = { responses in // responses contains the list of module responses indicating success or failure for each module print("Tealium ready - your completion code goes here!") } let tealium = Tealium(config: config, completion: completionHandler) track Tracks an event with associated data and, optionally, triggers a callback function. track(title:String, data:[String:Any], completion:ClosureType) Parameters Type Description title String The name of the event to be tracked data Dictionary An object of key/value pairs with data associated with the event to be tracked completion ClosureType A function to execute upon completion of the tracking call // Sample tracking let mydata = ["someKey": "someValue"] // track call with type specified and completion block tealium?.track(title: "someEvent", data: mydata, completion: { (success: Bool, info: [String:Any]?, error: Error?) in // Any follow up code here }) trackView Tracks a screen view with associated data and, optionally, triggers a callback function. trackView(title:String, data:[String:Any], completion:ClosureType) Parameters Type Description title String The name of the screen view to be tracked data Dictionary object An object of key/value pairs with data associated with the event to be tracked completion ClosureType A function to execute upon completion of the tracking call // Sample tracking let mydata = ["someKey": "someValue"] // track call with type specified and completion block tealium?.trackView(title: "some screen title", data: mydata, completion: { (success: Bool, info: [String:Any]?, error: Error?) in // Any follow up code here }) Future Improvements No planned changes Change Log Build 1.6.5 Made some methods and properties public to support modularization. Module responses removed from completion closure for simplicity Build 1.4.0 Removed deprecated track method with TealiumTrackType. Should now call trackView or trackEvent methods instead to differentiate between track call types "tealium_event_type" has been removed from all outgoing track calls, as it is now derived in UDH Event Specs and does not need to be sent Added "call_type" variable to view calls. Added "screen_title" to view calls, which is set to the "title" parameter passed into the trackView call. For "track" calls, "tealium_event" is set to the String value that is passed in as the first parameter. ... View more

Purpose Object provides a central place for configuring tracking options for the Tealium API. Individual modules provide their own extensions for the TealiumConfig class if they are enabled. Supported Platforms iOS tvOS watchOS macOS Installation Included with the TealiumCore framework CocoaPods pod 'tealium-swift/TealiumCore' import TealiumSwift Carthage TealiumCore.framework import TealiumCore Public API TealiumConfig Constructor for a TealiumConfig object. This object is required to initialize the library for your specific account. TealiumConfig(account:String, profile:String, environment:String, optionalData:Dictionary, dataSource:String) Parameters Type Description account String Tealium account name profile String Tealium profile name (usually "main") environment String Tealium environment: "dev", "qa", or "prod" optionalData [String: Any]? Parameter is optional, and may be omitted if you don't need it. See explanation on optionalData below datasource String Datasource key (available from UDH). Optional. // SAMPLE // standard basic config object let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") // with optionaldata and datasource let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod", optionalData: nil, datasource: "2f5s1") // with datasource but no optionalData let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod", datasource: "2f5s1") optionalData Allows certain default behavior to be overridden at init time. Generally, it is better to use the override methods, rather than explicitly specifying an optionalData object. OptionalData key Data Type Function TealiumTagManagementConfigKey.maxQueueSize Int Integer representing the maximum queue size for cached (offline) events TealiumTagManagementConfigKey.overrideURL String Override URL for Tag Management webview TealiumCollectKey.overrideCollectUrl String Override URL for Tealium Collect HTTPS requests TealiumDeviceDataModuleKey.isMemoryReportingEnabled Bool Turns low-level device memory reporting on (true) or off (false - default) TealiumAttributionKey.isSearchAdsEnabled Bool Enables support for the Apple Search Ads API in the attribution module (default off - false) setModulesList The list of modules to be enabled or disabled. (see Modules List) setModulesList(TealiumModulesList) Parameters Type Description modulesList TealiumModulesList* List of modules to enable or disable // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") // blacklists the autotracking module let modulesList = TealiumModulesList(isWhitelist: false, moduleNames: ["autotracking"] config.setModulesList(modulesList) *TealiumModulesList struct Parameters Type Description isWhiteList Bool Determines if modules list is a blacklist ( false ) or a whitelist ( true ) modulesList [String] Array of module names to enable or disable getModulesList Returns the current module list object. (see Modules List) getModulesList() -> TealiumModulesList // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") // blacklists the autotracking module let modulesList = config.getModulesList() setLogLevel Sets a new log level setLogLevel(logLevel: TealiumLogLevel) Parameters Type Description logLevel TealiumLogLevel New Log Level (see Swift Module: Logger) // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") // .none .errors .warnings .verbose let newLogLevel = TealiumLogLevel.errors config.setLogLevel(logLevel: newLogLevel) getLogLevel Returns the current log level (see Swift Module: Logger) getLogLevel() -> TealiumLogLevel let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") let logLevel = config.getLogLevel() setTagManagementOverrideURL Overrides the default URL used by the non-rendered UIWebView used by the Tag Management module. This should generally be avoided unless you are self-hosting your Tealium JavaScript files. setTagManagementOverrideURL(string: String) Parameters Type Description string String String representing a URL to be loaded by the Tealium UIWebView // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") let url = "https://tags.mycdn.com/utag/myaccount/myprofile/myenv/mobile.html" config.setTagManagementOverrideURL(string: url) setTagManagementQueueSize Sets the maximum tag management queue size setTagManagementQueueSize(to: Int) Parameters Type Description to Int Maximum queue size // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") config.setTagManagementQueueSize(to: 1) setCollectOverrideURL Overrides the Tealium Collect URL to send data to a different endpoint. setCollectOverrideURL(string:String) Parameters Type Description string String String representing a URL for the Collect module to send data to. Can be used to force data collection to stay within a particular region (e.g. EU Central/Germany) // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") // force override tealium collect base URL to EU Central let url = "https://collect-eu-central-1.tealiumiq.com/vdata/i.gif?" config.setCollectOverrideURL(string: url) setMemoryReportingEnabled Enables or disables memory reporting in the DeviceData module (default: disabled). setMemoryReportingEnabled(Bool) Parameters Type Description enabled Bool Enables or disables memory reporting in the Device Data module. // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") config.setMemoryReportingEnabled(true) isMemoryReportingEnabled Returns a Bool indicating whether memory reporting is currently enabled or disabled. isMemoryReportingEnabled() -> Bool // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") let enabled = config.isMemoryReportingEnabled() setSearchAdsEnabled Enables or disables memory reporting in the DeviceData module (default: disabled). setSearchAdsEnabled(Bool) Parameters Type Description enabled Bool Enables or disables Apple Search Ads API in the Attribution module // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") config.setSearchAdsEnabled(true) isSearchAdsEnabled Returns a Bool indicating whether the Apple Search Ads API is currently enabled or disabled in the Attribution module. isSearchAdsEnabled() -> Bool // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") let enabled = config.isSearchAdsEnabled() disableRemoteHTTPCommand Disables the built-in remote HTTP command (see Swift Module: RemoteCommands). disableRemoteHTTPCommand() // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") config.disableRemoteHTTPCommand() enableRemoteHTTPCommand Enables the built-in remote HTTP command (see Swift Module: RemoteCommands). enableRemoteHTTPCommand() // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") config.enableRemoteHTTPCommand() dispatchQueue Returns the current dispatch queue used for all Tealium processes. dispatchQueue() -> DispatchQueue let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") let dispatchQueue = config.dispatchQueue() setDispatchQueue Sets a new dispatch queue for Tealium to use. Not recommended. Default is DispatchQueue.main. setDispatchQueue(DispatchQueue) Parameters Type Description DispatchQueue DispatchQueue A dispatch queue to be used by Tealium let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") let dispatchQ = DispatchQueue(label: "com.tealium.myqueue") config.setDispatchQueue(dispatchQ) defaultDispatchQueue Returns the default dispatch queue (DispatchQueue.main). defaultDispatchQueue() -> DispatchQueue let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") let dispatchQueue = config.dispatchQueue() addDelegate Adds a new delegate conforming to the TealiumDelegate protocol. addDelegate(Delegate) Parameters Type Description delegate TealiumDelegate A class conforming to the TealiumDelegate protocol // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") // assuming current module has implemented the TealiumDelegate protocol config.addDelegate(self) delegates Returns an array of the currently-enabled delegates. delegates() -> [TealiumDelegate] // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") let delegates = config.delegates() setConnectivityRefreshEnabled If enabled (default), the connectivity module will check for a connection at a specified interval (controlled via setConnectivityRefreshInterval ). Queued dispatches will then be sent as soon as a connection is resumed. setConnectivityRefreshEnabled(Bool) Parameters Type Description enabled Bool Sets the enabled state of the connectivity refresh feature in the Connectivity module. Default true // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") config.setConnectivityRefreshEnabled(true) // set to false to disable this feature setConnectivityRefreshInterval Sets the default connectivity refresh interval in seconds. Default is 30 seconds if not set on the TealiumConfig instance. setConnectivityRefreshInterval(Int) Parameters Type Description interval Int Number of seconds after which the connectivity module will test for connectivity if the device is offline // sample let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") config. setConnectivityRefreshInterval(5) // sets interval to 5 seconds addRemoteCommand Adds remote commands for later execution addRemoteCommand(TealiumRemoteCommand) Parameters Type Description command TealiumRemoteCommand Instance of a TealiumRemoteCommand to be added // run prior to Tealium initialization #if os(iOS) let remoteCommand = TealiumRemoteCommand(commandId: "test", description: "test") { response in print("Remote Command 'test' executed") } config.addRemoteCommand(remoteCommand) #endif getRemoteCommands Returns an array of remote commands set on the TealiumConfig instance getRemoteCommands() ->[TealiumRemoteCommand]? let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") let remoteCommands = config.getRemoteCommands() setLegacyDispatchMethod Forces Collect module to use the legacy "vdata" GET request dispatcher instead of the default "/event" POST request dispatcher. setLegacyDispatchMethod(Bool) Parameters Type Description _ Bool If true , forces Collect module to use legacy "vdata" dispatch method let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev/qa/prod") config.setLegacyDispatchMethod(true) Future Improvements No planned changes. Change Log 1.6.5 TealiumModulesList is no longer required if you are only importing the specific modules you require. It will, however, continue to function as expected if present. Added methods for Connectivity module 1.4.0 Documentation updates Additional config methods/properties added for new module functionality ... View more

This guide shows how to add Tealium to your Roku app to track user activity.  Before you begin, here's a video introduction to the platform: Table of Contents Placeholder Installation Requirements Before proceeding, ensure you have satisfied the following requirements: Roku SDK 7.2 or higher Active Roku Developer Account Roku Device Tealium account enabled for AudienceStream, DataAccess, or EventStream We recommend developing in Eclipse with the Roku plugin. Get the Code The code for the Tealium Roku library is stored on Github. You must download and install the library. Download: Tealium for Roku We recommend cloning the library (instead of downloading) to make it easier to update to future releases. Code Setup The code is organized as a sample app. The Tealium code files are located in sample_app/source/tealium . The following files must be imported into your project's source folder: tealium.brs tealiumCollect.brs tealiumLog.brs If you are using Eclipse, refresh your project to access the Tealium components. The code for a sample app is available in the sample_app/source/application/main.brs file. Here you will see examples of adding button tracking and defining a callback function. Watch this video for an overview of the installation and setup of the code: Initialization Once the Tealium components are added to your project you are ready to start coding. The Tealium instance must be invoked with the following parameters before you can begin tracking: account - the name of your account profile - the name of your profile log level - a number 0-3 where 0=None, 1=Errors, 2=Warnings, and 3=Verbose environment - (optional) one of "qa" or "prod" datasource - (optional) the data source key rom UDH Tealium objects are constructed using a builder pattern. builder = TealiumBuilder("ACCOUNT", "PROFILE", 1) builder.SetEnvironment("prod") builder.SetDatasource("DATASOURCE") teal = builder.Build() Be sure to set an appropriate log level when your app is released to production. Tracking Once the Tealium instance has been defined you can begin tracking events with the method TrackEvent() , which takes the following parameters: Event Name (required) - a name to identify the event Event Data (optional) - Object with event data as key/value pairs Callback Function (optional) - Object with a function assigned to the "callback" key data = CreateObject("roAssociativeArray") data.someKey = "someValue" cb = CreateObject("roAssociativeArray") cb.callBack = Function (event) responseHeaders = event.GetResponseHeaders() responseKeys = responseHeaders.Keys() responseCode = event.GetResponseCode() for each key in responseKeys value = responseHeaders[key] print key + " : " + value End for End Function teal.TrackEvent("someEvent", data, cb)  The callback function can be used for a number of purposes, such as: building a retry or fallback system for failed calls building a queueing or throttling system customizing the Logger chaining application logic  Validation Use LiveEvents or Trace to validate that Tealium is receiving your tracking calls. Follow these steps to create a Stream for Roku events: Go to Live Events and cilck Add Stream Set the Title to "Roku Events" Set the Condition to tealium_library_name equals (Custom Value) "roku" Save the Stream Now you can easily filter events using the "Roku Events" Stream. Follow these steps to add a Trace to your app: Get a Trace ID from Visitor Trace in UDH Add a  tealium_trace_id  variable to the data object of your tracking calls and assign it the Trace ID. Trigger events in your Roku app Verify those tracking calls in Visitor Trace Watch this video for a demonstration of using and Trace to validate your implementation: Function Definitions This section specifies the syntax of the functions available in the Tealium for Roku library. Apps for Roku are written in BrightScript, a powerful scripting language. For more information read Roku's BrightScript Language Reference. TealiumBuilder() TealiumBuilder(account as String, profile as String, logLevel as Integer) as Object A builder function to help initialize the Tealium object. Set optional parameters using the utility functions. Create the Tealium object by calling Build(). builder = TealiumBuilder("ACCOUNT", "PROFILE", 1) builder.SetEnvironment("prod") builder.SetDatasource("DATASOURCE") teal = builder.Build() Parameters Type Description account String Tealium account name profile String Tealium profile name (default: "main") environment (optional) String Tealium environment: "qa" or "prod" datasource (optional) String A data source key from UDH eg. "abc123" createTealium() createTealium(account as String, profile as String, env as String, logLevel as Integer) as Object Creates a Tealium object that will be used to track events. teal = createTealium("account", "profile", "env", 3)  Parameters Type Description account String Tealium account name profile String Tealium profile name (usually "main") env String Tealium environment: "qa" or "prod" log level Integer Log level: 0=None, 1=Errors, 2=Warnings, 3=All trackEvent() trackEvent(eventType as String, eventName as String, data as Object, callback as Object) as Void Tracks an event with associated data and, optionally, triggers a callback function. Parameters Type Description eventType String Tealium event type (activity, conversion, derived, interaction, or view) eventName String Name of event (becomes the event_name  attribute in UDH) data Object Contextual event data, an "roAssociativeArray" Object containing keys and values callback Object An Object with a function property named 'callback' that accepts a "roEvent" argument. The callback function will be triggered upon completion of the TrackEvent call. data = CreateObject("roAssociativeArray") data.testKey = "testValue" cb = CreateObject("roAssociativeArray") cb.callBack = Function(event) print "Callback called!" End Function teal.trackEvent("activity", "someEvent", data, cb)  resetSessionId() resetSessionId() as Integer Resets and returns a new session ID. The session ID identifies the current user session, similar to a website session, but it does not expire. A new session ID is created each time createTealium() is called.  teal.resetSessionId() toStr() toStr() as String Returns a readable string containing the configuration details of the current Tealium instance eg. "Tealium instance for account: ACCOUNT profile: PROFILE environment: ENV" print teal.toStr()   Change Log - 1.1.0 Update trackEvent takes an additional String type arg with one of the following values: activity conversion derived interaction view Additional Tealium variable: tealium_event_type - 1.0.0 Initial Release ... View more

This article shows how to troubleshoot a mobile implementation of iQ Tag Management via the published file mobile.html. In this article: Table of Contents Placeholder Overview When you activate a mobile profile in Tealium iQ a file named mobile.html is published to the following path on the CDN: http://tags.tiqcdn.com/utag/{account} /{profile}/{environment}/mobile.html This file is used by the native mobile library to receive mobile publish settings and to facilitate the Tag Management module. This file can be useful to perform some basic troubleshooting of your mobile implementation.  Inspecting mobile.html  The behavior of utag.js on the mobile.html page will be similar to that of a standard desktop website page. The utag.js file is loaded and subsequent vendor tags are executed. To inspect the mobile.html page: Load the mobile.html URL for your iQ profile in a new browser window. Open the developer tools or web console of the browser to inspect the page source: From here you can now perform many of the same troubleshooting techniques that you would use for a website witih Tealium's utag.js installed. Verifying the Publish Timestamp The first thing to verify is that your most recently published changes are being loaded in mobile.html. This is done by matching the timestamp from the HTML source to the timestamp from the iQ Versions screen. To verify the publish timestamp: At the top of the page source of mobile.html, look for the published timestamp on the first line. The timestamp in mobile.html has the following pattern: ut.4.0.YYYYMMDDHHMM . (Time is always in GMT.) In your iQ profile, go the Versions screen and find the most recently published version of the same environment. The timestamp of this publish should match the timestamp found inside mobile.html. Inspecting Mobile Publish Settings JavaScript Object The mobile.html page uses a JavaScript object named mps  to store the values of the mobile publish settings. You can inspect this object to verify your settings. To inspect the mps object: Type "mps" into the web console and hit enter. The properties marked "4" and "5" correspond to versions 4.x and 5.x of your mobile library respectively.  Simulating Tracking Calls The behavior of utag.js on this page will be similar to that of a standard desktop website page. This means you can watch the network activity to see which utag.*.js files are loaded and you can trigger tracking calls from the browser console to verify that your tags are working as expected. To simulate tracking calls in mobile.html: From the browser console, type utag.view({screen_title : "Test Page"}) and hit enter. Go to the network activity screen to inspect the outgoing vendor tracking activity.     ... View more

The Tealium Lifecycle Module provides app lifecycle tracking capability to an existing 5.x implementation of the Tealium Android framework.   This guide covers the following topics:   Table of Contents Placeholder Installing The Lifecycle Module dependency can be added manually, or via Tealium's Maven repository.   Manual Install  The module can be downloaded here: Tealium Android Lifecycle Tracking Module. Follow these steps add the module to your app: Add tealium.lifecycle-1.x.x.aar to <PROJECT_ROOT>/<MODULE>/libs . Add the Tealium library dependency to your build.gradle file: dependencies { implementation(name:'tealium.lifecycle-1.1.2', ext:'aar') }   Maven Install  Ensure you have the Tealium Maven repo added in your project's build.gradle file // Top-level build file where you can add configuration options common to all sub-projects/modules. buildscript { repositories { jcenter() } dependencies { classpath 'com.android.tools.build:gradle:2.3.3' } } allprojects { repositories { jcenter() // Tealium Maven repo directive maven { url "http://maven.tealiumiq.com/android/releases/" } } } In your app-level build.gradle  file, add the Tealium lifecycle module. The current version is 1.1.2: dependencies { // only add if not already present implementation 'com.tealium:library:5.5.4' // add lifecycle to list of dependencies implementation 'com.tealium:lifecycle:1.1.2' } Tracking The module tracks the following lifecycle events: launch sleep wake These events are indicated in the lifecycle_type  variable. Automatic Tracking Tealium Lifecycle tracking solely associates usage with the Activity lifecycle. The library leverages the Application.ActivityLifecycleCallbacks API and evaluates its conditions on onActivityResumed and onActivityPaused. To enable, call: Tealium.Config config = Tealium.Config.create(application, "YOUR_ACCOUNT", "YOUR_PROFILE", "ENVIRONMENT"); boolean isAutoTracking = true; // Additional instance for Lifecycle tracking LifeCycle.setupInstance("INSTANCE_NAME", config, isAutoTracking); // Standard Tealium instance Tealium.createInstance("INSTANCE_NAME", config);   Launch Event Generated on the first onActivityResumed to occur. If onActivityPaused is called before onActivityResumed (when the library is initialized in the middle of the Activity lifecycle), then the module creation time is used to generate a launch event. Sleep Event Generated 5 seconds after onActivityPaused is called and onActivityResumed was not called. This indicates that the application has been backgrounded because a new view has not been presented. Wake Event Generated during onActivityResumed when more than 5 seconds has elapsed since the last onActivityPaused . This indicates that onActivityResumed is called because the app is foregrounding and not because of a view change. Manual Tracking Available for specific lifecycle paradigms and unconventional lifecycle tracking. This approach is not recommended for most implementations. To allow manual lifecycle tracking update your lifecycle initiation code to set isAutoTracking to false . Tealium and the attached LifeCycle multitons are remote-killable by pubish settings in Tealium iQ. Null checks should be performed when getting the instances to call their methods.  Launch Event To manually track a launch event, call trackLaunchEvent : LifeCycle lifeCycle = LifeCycle.getInstance(TEALIUM_INSTANCE_ID); if(lifeCycle != null) { // OPTIONAL Map<string, string=""> data = new HashMap<>(); data.put("boot_time", "5ms"); lifeCycle.trackLaunchEvent(data); } Sleep Event To manually track a sleep event, call trackSleepEvent : LifeCycle lifeCycle = LifeCycle.getInstance(TEALIUM_INSTANCE_ID); if(lifeCycle != null) { // OPTIONAL Map<string, string=""> data = new HashMap<>(); data.put("foreground_time", "4000ms"); lifeCycle.trackSleepEvent(data); } Wake Event To manually track a wake event, call trackWakeEvent : LifeCycle lifeCycle = LifeCycle.getInstance(TEALIUM_INSTANCE_ID); if(lifeCycle != null) { // OPTIONAL Map<string, string=""> data = new HashMap<>(); data.put("background_time", "600000ms"); lifeCycle.trackWakeEvent(data); } Crash Detection When a launch event follows a wake event or vice-versa, this indicates a crash has occurred since the app did not successfully sleep . If the aforementioned sequence occurs because of a Tealium library shutdown, this is not considered to be a crash event. When a crash event is detected, the launch or wake event data will have the lifecycle_diddetectcrash  variable will be added. { "lifecycle_type" : "launch", "lifecycle_diddetectcrash" : "true", //... } Data Layer Variables The module adds the following additional variables for the listed event types (launch, wake, sleep): Variable Description Type Example Event lifecycle_dayofweek_local Local day of week that call was made - 1=Sunday, 2=Monday, etc.) Number "13" all lifecycle_dayssincelaunch Days since first launch in integer increments Number "23" all lifecycle_dayssinceupdate Days since the last detected app version update in integer increments Number "46" all lifecycle_dayssincelastwake Days since last detected wake in integer increments Number "1" all lifecycle_diddetectcrash Only present if a launch event follows a wake event (crash inferred from missing prior sleep event) Boolean "true" launch lifecycle_firstlaunchdate GMT timestamp of very first detected launch/wake in ISO8601 format from Zulu time String "2013-07-11T17:55:04Z"  all   lifecycle_firstlaunchdate_MMDDYYYY  GMT Timestamp formatted as MM/DD/YYYY  String "01/18/2012"   all lifecycle_hourofday_local Local hour of day that call was made (24 hour format)  String "true"  all lifecycle_isfirstlaunch Only present if call is very first launch call String "true" launch lifecycle_isfirstlaunchupdate  Only present if call is first launch after a detected updated Boolean "true" launch lifecycle_isfirstwakemonth Only present if call is first launch/wake of the month Boolean "true" launch, wake  lifecycle_isfirstwaketoday Only present if call is first launch/wake of the day  Boolean  "true" launch, wake lifecycle_launchcount Total number of launches this version of your app (since the last updtae) Number "3"   all lifecycle_secondsawake Whole seconds app was awake since last wake/launch. Sent only with lifecycle_type:sleep or lifecycle_type:terminate calls Number "30" all   lifecycle_priorsecondsawake  Whole seconds app was awake since last launch only. Aggregates total from all wakes prior. Sent only with lifecycle_type: launch calls.  Number  "126"   all lifecycle_sleepcount Total number of times your app has gone to sleep (resets if updated)  Number  "5"    all lifecycle_totalcrashcount Total number of crashes counted since install  (only reset if app deleted)  Number  "21"    all lifecycle_totallaunchcount Total number of launches since install  (only reset if app deleted)  Number  "3"    all lifecycle_totalsecondsawake  Total number of seconds your app has been in a woken/active state since app install  (only reset if app deleted)  Number  "36"   all lifecycle_totalsleepcount  Total number of times your app has gone into the background since app install  (only reset if app deleted)   Number  "400"   all lifecycle_totalwakecount  Total number of launches + wakes since install (only reset if app deleted)  Number   "563"   all lifecycle_type   Type of lifecycle call String "initial", "launch", "wake", "sleep", "terminate"   all lifecycle_updatelaunchdate  GMT timestamp of first wake/launch after a version update has been detected  String  "2014-09-08T18:10:01Z"   all lifecycle_wakecount  Total number of launches + wakes in this version of your app (resets if updated)  Number   "29"   all     ... View more

Once you have the Tealium for Android library added to your app and have configured your mobile iQ profile you are ready to validate your installation. The type of installation will determine the best method for validating. Before You Begin We recommend using a build of your app configured for the "dev" environment rather than "prod" environment. This allows you to use the iQ Publish Environments to isolate your  "dev" configuration from your "production" configuration. The environment is set in the Initialization part of your app's code. This article covers the following topics related to validating your Tealium for Android installation: Table of Contents Placeholder Configuring Your Android App to Use Live Events You can use the Live Events feature of EventStream for the purpose of validating your mobile apps. Live Events will show tracking calls in real-time and is the easiest way to verify that your mobile app is sending data. EventStream/AudienceStream Customers For customers with EventStream/AudienceStream, there are two ways that data will come into the Live Events service: (1) through the Tealium Collect Tag configured for mobile apps using Tag Management and (2) directly from the device for mobile apps using the Collect dispatch service. Read more about these mobile configuration options. Non-AudienceStream Customers Access to Live Events is still available, but is limited to the "dev" environment. If you enable this in a production environment you will be charged for the number of events Tealium processes. Remember to disable these settings prior to a production release. Your EventStream/AudienceStream account must be published before live events will be detected. To send data to Live Events through Tag Management: In your mobile iQ Profile, add the Tealium Collect tag. In the Advanced Settings of the tag, toggle off the QA and Prod publish environments. Publish the Profile to the "Dev" environment. Configure your app to load the "Dev" environment. To send data to Live Events through the mobile Collect library: In your mobile iQ Profile, go to the Mobile Publish settings and enable the Tealium Collect dispatch service. Publish the Profile to the "Dev" environment. Configure your app to load the "Dev" environment. Now when you launch and use your app the tracking calls can be monitored in Live Events. Creating a Live Events Stream for Mobile Live Events will display event activity coming from all tracking sources, but you can create an event feed based on any of the event attributes being passed. This can helpful when validating your mobile installation. To create an event feed for your mobile app: Navigate Live Events. Click Add Event Feed. Enter a title eg. "Mobile Events". Add the condition: tealium_library_name equals (Custom Value) "Android" Click Save The event feed condition can be based on any attribute that uniquely identifies events coming from your app. Read more about creating event feeds.   ... View more

The following variables are populated by the Tealium Android Library as part of the mobile data layer. These variables are included automatically in each tracking call from the library and can now be used in your iQ or AudienceStream configurations. These variables are added to the data layer of your iQ profile when you activate the profile for mobile use.  Addition variables are available in the Lifecycle Tracking Module for 5.0.x. Variable Name Android Version Description app_build 5.4+ App build version e.g. "1" app_name 1.1+ Application name (from the <application> manifest attribute "android:label") app_memory_usage 5.4+ Memory in use by app process (MB) e.g. "57" app_rdns 3.0+ Reverse DNS application ID (from the root manifest attribute "package") app_version 1.1+ Application version [any string] call_type 2.0+ Call type [view/link] carrier 1.1+ Carrier device is currently on [ATT, Verizon, etc.] carrier_iso 1.1+ Carrier iso country code - ISO 3166-1 carrier_mcc 1.1+ Mobile country code - ITU-T Recommendation E.212 carrier_mnc 1.1+ Mobile network code connection_type 1.1+ [wifi, cellular, etc.] device 1.1+ [iphone, ipad, etc.] device_android_runtime 5.4+ Android Runtime version e.g. "2.1.0" device_available_external_storage 5.4+ Total available external storage on device device_available_system_storage 5.4+ Total available storage on device e.g. 273772544 device_architecture 3.0+ Bit architecture of the device [32, 64, etc] device_battery_percent 4.0+ Whole number percent representation of device's remaining power [20, 50,...] device_cputype 3.0+ Cpu type [arm6, arm7, arm7s, etc] device_ischarging 4.0+ Is the device actively charging [true, false] device_language 3.0+ Two-letter ISO-639-1 language setting identifier [en, ja, etc.] device_orientation 5.0+ Orientation of device at time of call [Portrait, Landscape Left, Landscape Right, Portriat UpsideDown, Face Up, Face Down, Unknown] device_os_build 5.4+ Operating System build version e.g. "4499259" device_os_version 5.0+ Operating System version on device [7.0] event_name 5.0+ "mobile_link" required by vdata library_version 1.2+ The version of the Tealium library your app has installed lifecycle_dayofweeklocal* 1.2+ Local day of week that call was made (ie 1=Sunday, 2=Monday, etc.) lifecycle_day ssincelastwake * 1.2+ Days since last detected wake in integer increments lifecycle_dayssincelaunch* 1.2+ Days since first launch in integer increments lifecycle_dayssinceupdate* 1.2+ Days since the last detected app version update in integer increments lifecycle_diddetectcrash* 5.0.3+ Populated 'true' on launch events if crash was determined. lifecycle_firstlaunchdate* 1.2+ GMT timestamp of very first detected launch/wake in ISO8601 format from Zulu time (ie 2013-07-11T17:55:04Z) lifecycle_firstlaunchdate_MMDDYYYY* 1.2+ GMT Timestamp formatted as MM/DD/YYYY (ie 01/18/2012) lifecycle_hourofday_local* 1.2+ Local hour of day that call was made (24 hour format) lifecycle_isfirstlaunch* 1.2+ Only present if call is very first launch/wake call (value = true) lifecycle_isfirstlaunchupdate* 1.2+ Only present if call is first launch/wake after a detected updated lifecycle_isfirstwakemonth* 1.2+ Only present if call is first launch/wake of the month (value = true) lifecycle_isfirstwaketoday* 1.2+ Only present if call is first launch/wake of the day (value = true) lifecycle_lastlaunchdate* 1.2+ GMT timestamp of last recorded launch in ISO8601 format from Zulu time (ie 2013-07-11T17:55:04Z) lifecycle_lastsleepdate* 1.2+ GMT timestamp of last recorded sleep in ISO8601 format from Zulu time (ie 2013-07-11T17:55:04Z) lifecycle_lastwakedate* 1.2+ GMT timestamp of last recorded wake in ISO8601 format from Zulu time (ie 2013-07-11T17:55:04Z) lifecycle_launchcount* 1.2+ Total number of launches this version of your app (resets if app version updates) lifecycle_priorsecondsawake * 1.2+ Whole seconds app was awake since last launch only. Aggregates total from all wakes prior. Sent only with lifecycle_type: launch calls lifecycle_secondsawake* 1.2+ Whole seconds app was awake since last wake/launch. Sent only with lifecycle_type:sleep lifecycle_sleepcount* 1.2+ Total number of times your app has gone to sleep (resets if app version updates) lifecycle_totalcrashcount* 5.0.4+ Total number of times crashes were detected. Does not reset unless app resintalled. lifecycle_totallaunchcount* 1.2+ Total number of launches since install. Does not reset unless app resintalled. lifecycle_totalsecondsawake* 1.2+ Total number of seconds your app has been in a woken/active state. Does not reset unless app resintalled. lifecycle_totalsleepcount* 1.2+ Total number of times your app has gone into the background since install. Does not reset unless app resintalled. lifecycle_totalwakecount* 1.2+ Total number of launches + wakes since install. Does not reset unless app resintalled. lifecycle_type* 1.2+ Type of lifecycle call (ie launch, wake, sleep) lifecycle_updatelaunchdate* 1.2+ GMT timestamp of first wake/launch after a version update has been detected. ISO8601 format from Zulu time (ie 2013-07-11T17:55:04Z) lifecycle_wakecount* 1.2+ Total number of launches + wakes in this version of your app (resets if app version updates) link_id 1.0+ (EVENT CALLS ONLY) General event or link title - this could be a button title or an object's Tealium ID [any string] orientation 2.0+ DEPRECATED Orientation of device at time of call [Portrait, Landscape Left, Landscape Right, Portriat UpsideDown, Face Up, Face Down, Unknown] origin 3.0+ Constant that can be used in mapping to distinguish mobile from web implementations [mobile] os_version 1.1+ Operating System version on device [7.0] page_type 5.0+ "mobile_view" constant that can be used in mapping to distinguish mobile view / page changes from mobile or web events - required by vdata platform 1.0+ [iOS, Android, BB10, etc.] screen_title 1.0+ (VIEW CALLS ONLY) General view title [any string] timestamp 1.1+ Timestamp to seconds of event occurrence (ie 2013-07-11T19:57:47Z) [ISO8601 at Zulu] timestamp_local 2.0+ Local Timestamp to seconds of event occurrence (ie 2013-07-11T19:57:47) [ISO8601 without offset] timestamp_offset 2.0+ Local timezone offset of device's location in hours (ie -3) timestamp_unix 1.1+ GMT/UTC Unix timestamp (ie 1373498679) of event occurrence. timestamp_unix_milliseconds 5.5.1 GMT/UTC Unix timestamp in milliseconds (ie 1373498679123) of event occurrence. uuid 1.2+ (Universally Unique Identifier) Unique for each installation of an app on a device. [any string] visitor_id 5.0+ Tealium-generated visitor_id   ... View more

This guide shows how to add Tealium to your Android Mobile or Android TV app to track user activity. Table of Contents Placeholder Requirements Android Studio Android API Level 19 and higher (KitKat/4.4) For use with iQ Tag Management: Mobile Profile in iQ (see Creating a Mobile Profile) For use with Universal Data Hub: Account enabled for AudienceStream, DataAccess, or EventStream. Get the Code The code for the Tealium Android library can be found on Github. You must download and install the library before proceeding. Download: Tealium for Android Cloning the library, instead of downloading, will make it easier to update to future releases. Installation The current version of the Tealium Android library is 5.5.4, released on 1/23/2019 Tealium uses Maven to install and manage dependencies. Add the Tealium Maven URL to your project root  build.gradle  file: allprojects { repositories { jcenter() maven { url "http://maven.tealiumiq.com/android/releases/" } } } Add the Tealium dependency to your project module  build.gradle file: dependencies { implementation 'com.tealium:library:5.5.4' } Add to Project Manually You can also add the dependency manually. Add flatDir to your project root  build.gradle file: allprojects {     repositories {         jcenter()         flatDir {             dirs 'libs'         }     } } Add tealium-5.x.x.aar to <PROJECT_ROOT>/<MODULE>/libs . Add the Tealium library dependency to your build.gradle file:  dependencies {     implementation(name:'tealium-5.5.4', ext:'aar') }  Initialization The Tealium instance must be configured with the following parameters before it will begin tracking: account - the name of your account profile - the name of your profile environment - one of "qa" or "prod" datasource - (optional) the data source key from UDH instance - a unique name for your instance (multiple instances are supported) Add the following code to the onCreate method in the Application sub-class: Tealium.Config tealConfig = Tealium.Config.create(application, "ACCOUNT", "PROFILE", "ENVIRONMENT"); // Currently optional - add a 6 character alphanumeric data source ID. // If you have not been given a data source ID, you can omit this. Note that this is a mock value tealConfig.setDataSourceId("abc123"); /* setForceOverrideLogLevel - optional - forces the log level to be set to one of "dev", "qa", "prod" or "silent". * Overrides remote publish setting. Remote publish settings used if omitted. */ tealConfig.setForceOverrideLogLevel("prod"); Tealium.createInstance("INSTANCE", tealConfig); When Collect is enabled, v.5.5.1 and above - data will be sent to profile provided in Tealium.Config object v.5.5.0 and below - data will be sent to "main" profile Tracking Views Every time a user opens or changes a screen in the app a tracking call should be made.   A view is tracked by calling trackView()  with two parameters: the name of the screen and (optionally) contextual view data.  The screen name will be populated in the event data as the screen_title  variable. Map<String, Object> data = new HashMap<>(1); data.put("someKey", "someValue"); Tealium.getInstance("INSTANCE").trackView("screenName", data); Tracking Events All non-view activity should be tracked as an event. This is easily done by calling trackEvent() with two parameters: an event name and (optionally) contextual event data. The event name will be populated in the event data as the tealium_event  variable. Map<String, Object> data = new HashMap<>(1); data.put("someKey", "someValue"); Tealium.getInstance("INSTANCE_NAME").trackEvent("someEvent", data);  Overriding The Default Log Level By default, the amount of logging performed by the Tealium library is controlled by the remote publish settings. Sometimes, however, this is not convenient for developers who may not have access to Tealium iQ to change the settings. Since release 5.3.1 of the Tealium library, we now support overriding the log level locally at initialization time. To set a specific log level, use the following snippet: Tealium.Config tealConfig = Tealium.Config.create(application, "ACCOUNT", "PROFILE", "ENVIRONMENT"); /* Options are: * "dev" (warnings, errors, info) * "qa" (errors & warnings only) * "prod" (errors only) * "silent" (no logging, but may produce a couple of lines of log output in cases where the config object hasn't yet been initialized) */ tealConfig.setForceOverrideLogLevel("dev"); // forces the log level to be set to dev Cookie Management  v5.1.0 and above - CookieManager is enabled by default.   v5.0.4 and below - CookieManager is disbabled by default. Enabling CookieManager is required if using Tag Management If you have enabled Tag Managements in your mobile profile then the following code can be added to activate cookie management. This code allows the Tag Management Webview to: acceptCookies acceptThirdPartyCookies acceptFileSchemeCookies This must be placed after the initialization statement. config.getEventListeners().add(createCookieEnablerListener()); private static WebViewCreatedListener createCookieEnablerListener() { return new WebViewCreatedListener() { @Override public void onWebViewCreated(WebView webView) { final CookieManager mgr = CookieManager.getInstance(); // Accept all cookies mgr.setAcceptCookie(true); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { mgr.setAcceptThirdPartyCookies(webView, true); } if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1) { CookieManager.setAcceptFileSchemeCookies(true); } Log.d(TAG, "WebView " + webView + " created and cookies enabled."); } }; } Additional Resources  Sample Apps API Documentation ... View more

Question How do I access the iOS device logs? Answer Install XCode on your computer. Connect your iOS to your computer with a USB or Lightning cable. Go to Window > Devices and select your device from the list. Click the "up" triangle at the bottom left of the right hand panel. All logs from all apps on the device will be displayed here. If the app is a production build,  it is likely that only critical errors/crashes will be logged. ... View more

Question How do I troubleshoot the hidden web view in Safari? Answer Follow Apple's instructions to enable the web inspector in Safari for Mac OS X and in the iOS device settings. Once you can see your device in the "Develop" menu, open "tags.tiqcdn.com/utag/[account]/[profile]/[environment]/mobile.html" in the list of open web pages on the device. Follow the guide for inspecting mobile.html. This also works when using the iOS Simulator to debug your app ... View more

Question How do I add IDFA to my mobile Data Layer? Answer The following is example code for adding an app's IDFA string to the Data Layer. Learn more about ASIdentifierManager. // Objective-C // 1. Place into a helper class that calls Tealium // 2. Add import statement at the top of the class with other imports - DON'T FORGET to // add the AdSupport.framework in your project's target build. @import AdSupport ; // 3. Add this class function + ( NSString *) identifierForAdvertising { if ([[ ASIdentifierManager sharedManager ] isAdvertisingTrackingEnabled ]){ NSUUID * idfa = [[ ASIdentifierManager sharedManager ] advertisingIdentifier ]; return [ idfa UUIDString ]; } return nil ; } // 4. Example Tealium initialization & adding the IDFA as a persistent data point. + ( void ) startTealium { TEALConfiguration * config = [ TEALConfiguration configurationWithAccount :@ "(account)" profile :@ "(profile)" environment :@ "(environment)" ]; Tealium * tealium = [ Tealium newInstanceForKey :@ "(uniqueId)" configuration : config ]; // Alternatively just add the following 2 lines to wherever a Tealium instance is // already initialized. NSString * idfa = [ self identifierForAdvertising ]; [ tealium addPersistentDataSources :@{@ "idfa" : idfa }]; }   ... View more

Question Does Tealium for iOS support HTTPS and TLS? Answer Yes, the Tealium iOS library supports HTTPS and TLS. The Tealium iOS library uses HTTPS for all communication with and the Tealium Multi-CDN was updated to meet Apple's TLS requirements at the end of 2015.  If you override the library's configuration URL with an HTTP location an exception will have be made in your App Transport Security exceptions.   ... View more

The code for the Tealium iOS library and other Tealium plugins can be found on Github. Version 5.x Tealium for iOS  Version 4.x Tealium for iOS Tealium PhoneGap Plugin Tealium Titanium Plugin Tealium Unity Plugin ... View more

Once you have the iOS library added to your app and have configured your mobile iQ Profile you are ready to validate your installation. The type of installation will determine the best method for validating. Before You Begin We recommend using a build of your app configured for the "dev" environment rather than "prod" environment. This allows you to use the iQ Publish Environments to isolate your  "dev" configuration from your "production" configuration. The environment is set in the Initialization part of your app's code. This article covers the following topics related to validating your Tealium for iOS installation: Table of Contents Placeholder Configuring Your iOS App to Use Live Events You can use the Live Events feature of AudienceStream for the purpose of validating your mobile apps. Live Events will show tracking calls coming into Tealium in real-time and is the easiest way to verify that your mobile app is sending data to Tealium correctly. AudienceStream Customers For customers with an AudienceStream account, there are two ways that data will come into the Live Events service: (1) through the Tealium Collect Tag configured for mobile apps using Tag Management and (2) directly from the device for mobile apps using the Collect dispatch service. Read more about these mobile configuration options. Non-AudienceStream Customers Access to Live Events is still available, but is limited to the "dev" environment. If you enable this in a production environment you will be charged for the number of events Tealium has processed. Remember to disable these settings prior to a production release. To send data to Live Events through Tag Management: In your mobile iQ Profile, add the Tealium Collect tag. In the Advanced Settings of the tag, toggle off the QA and Prod publish environments. Publish the Profile to the "Dev" environment. Configure your app to load the "Dev" environment. To send data to Live Events through the mobile Collect library: In your mobile iQ Profile, go to the Mobile Publish settings and enable the Tealium Collect dispatch service. Publish the Profile to the "Dev" environment. Configure your app to load the "Dev" environment. By default, the data sent using this method will be go to the "main" Profile in your account and not the currently selected Profile. You can change which Profile data is sent to by overriding the display URL in the library code. To send data to a custom Profile by overriding the dispatch URL, use the following code snippets with the desired account/profile: TEALConfiguration * configuration = [ TEALConfiguration configurationWithAccount :@ "[account]" profile :@ "[profile]" environment :@ "dev" ]; [ configuration setOverrideCollectDispatchURL : @ "https://collect.tealiumiq.com/ vdata/i.gif?tealium_account=[account]&tealium_prof ile=[profile]" ]; When using the mobile Collect service you will not see any data from the web view (e.g. cookie data or extension-generated data). You will only see the exact data that was passed to Tealium by the app itself. Now when you launch and use your app the tracking calls can be monitored in Live Events. Creating a Live Events Stream for Mobile Live Events will display event activity coming from all tracking sources, but you can create a filtered Stream of events based on any of the event attributes being passed. This can helpful when validating your mobile installation. To create a filtered Stream for your mobile app: In Universal Data Hub, navigate to Discover > Live Events. Click Add Stream > Filter by Event Attribute. Enter a title eg. "Mobile Events". Leave Event Data Storage disabled. Add the condition: tealium_library_name equals (Custom Value) "iOS" Click Save The Stream condition can be based on any attribute that uniquely identifies events coming from your app. Read more about Creating Streams.   ... View more

The Tealium Support Desk is designed to provide a self-service support portal. We know that many questions can be answered in the user forums or in the product documentation, but for those issues that require expertise or special attention you can submit a request directly to our support team. In this article: Table of Contents Placeholder Accessing Support Desk Support Desk is located at: https://support.tealiumiq.com/ You must sign in to submit a new support request or to review your past requests. Use the same credentials you use to access the Tealium Customer Data Hub and Tealium Learning Center. Submitting a support request You must be signed in to Support Desk to submit a new support request. Our goal is to provide the best service possible in a timely manner. You can help us by entering as much detailed information as possible in the request form. Following these steps and best practices will help expedite your request. Use the following steps to submit a new support request in the Tealium Support Desk portal: Click Submit a request at the top of the page. Enter a descriptive subject line. Example: "Facebook Pixel not firing on Confirmation page" instead of "Pixel broken" Enter a detailed description of the request. The following information is typically needed: Tag UID/Connector name Steps to reproduce QA site access information ie. username/password Test credit card/transaction details Vendor pixel code Relevant Load Rules, Data Mappings, or Extensions Attach any relevant screenshots or vendor documentation. The file size limit for attachments is 20MB. What to expect after submission Within one business day of submitting your ticket, a Tealium representative will be in contact to confirm your ticket submission and follow up with any clarifying questions. Next, your Tealium representative will work on assigning an appropriate resource to your request within two business days after submission. Checking the status of a support request You must be signed in to the Support Desk to check the status of a support request. To check the status of a request: At the top of the page click My activities. To filter the requests displayed, enter a search term in the Search requests or select an option from the Status menu. Click the title of the request to see the details. Creating a follow-up support request Once a solved request has been inactive, it will automatically be closed for additional comments and cannot be reopened.  To create a follow-up to a solved request: At the top of the page, click My activities. In the Status menu, select "Solved" to filter the list of requests. Click the title of the request to see its details. At the bottom of the request, click create a follow-up. Frequently Asked Questions  How do I link two related support requests? It's common for two requests to be related and it can be useful to reference one from the other. In the comment of a request mention the related request by typing the number sign ("#") followed by the request number eg. #123456. This will automatically be linked to the related request.  I have a question that's not listed here. What should I do? It's possible that someone else has your same question, or has already answered it. Trying searching the user forums for an existing article on your question. If nothing comes up you can be the first to post it to the community, and now the next person that has that question will find it in the forums.  ... View more

The Tealium Lifecycle Module provides app lifecycle tracking capability to an existing 5.0.x implementation of the Tealium iOS framework.   This guide covers the following topics:   Table of Contents Placeholder Installing The Lifecycle Module must be added to your app. The module can be downloaded here: Tealium iOS Lifecycle Tracking Module. To add the Lifecycle Module to your app: Add the TealiumIOSLifecycle.framework to your project Add the framework to your Project's: Target: General: Embedded Binaries section In any abstraction class (like TealiumHelper.h) replace any @import TealiumIOS with @import TealiumIOSLifecycle Tracking The module tracks the following lifecycle events: launch sleep wake none (for data added to events but not associated with a lifecycle event) These events are indicated in the lifecycle_type  variable. Automatic Tracking The module can be configured to automatically listen for the standard UIApplication notifications to automatically trigger launch, wake and sleep events. API options to disable are not currently public. Unlink or remove the TealiumTVOS_Lifecycle.framework from your project to remove lifecycle tracking.   Launch Event Generated on when a UIApplicationDidFinishLaunchingNotification notification detected. Sleep Event Generated on when a UIApplicationWillEnterForegroundNotification notification detected. Wake Event Generated on when a UIApplicationWillResignActiveNotification notification detected. Manual Tracking Available for specific lifecycle paradigms and non-conventional lifecycle tracking. These commands will be ignored if the setLifecycleAutotrackingIsEnabled: is set to YES / true Launch Event To manually track a launch event, call: [[Tealium instanceForKey:@"(uniqueInstanceId)"] launch]; Sleep Event To manually track a sleep event, call: [[Tealium instanceForKey:@"(uniqueInstanceId)"] sleep]; Wake Event To manually track a wake event, call: [[Tealium instanceForKey:@"(uniqueInstanceId)"] wake]; Data Layer Variables The module adds the following additional variables: Variable Description Type Example lifecycle_dayofweek_local Local day of week that call was made - 1=Sunday, 2=Monday, etc.) Number "13" lifecycle_dayssincelaunch Days since first launch in integer increments Number "23" lifecycle_dayssinceupdate Days since the last detected app version update in integer increments Number "46" lifecycle_dayssincelastwake Days since last detected wake in integer increments Number "1"   lifecycle_diddetectcrash Only present if a crash was detected.  Boolean "true" lifecycle_firstlaunchdate GMT timestamp of very first detected launch/wake in ISO8601 format from Zulu time String "2013-07-11T17:55:04Z"  lifecycle_firstlaunchdate_MMDDYYYY  GMT Timestamp formatted as MM/DD/YYYY  String "01/18/2012" lifecycle_hourofday_local Local hour of day that call was made (24 hour format)  String "true" lifecycle_isfirstlaunch Only present if call is very first launch/wake call String "true" lifecycle_isfirstlaunchupdate  Only present if call is first launch/wake after a detected updated Boolean "true" lifecycle_isfirstwakemonth Only present if call is first launch/wake of the month Boolean "true" lifecycle_isfirstwaketoday Only present if call is first launch/wake of the day  Boolean  "true" lifecycle_launchcount Total number of launches this version of your app (since the last updtae) Number "3" lifecycle_secondsawake Whole seconds app was awake since last wake/launch. Sent only with lifecycle_type:sleep or lifecycle_type:terminate calls Number "30" lifecycle_priorsecondsawake  Whole seconds app was awake since last launch only. Aggregates total from all wakes prior. Sent only with lifecycle_type: launch calls.  Number  "126" lifecycle_sleepcount Total number of times your app has gone to sleep (resets if updated)  Number  "5"  lifecycle_totalcrashcount Total number of crashes counted since install  (only reset if app deleted)  Number  "21"  lifecycle_totallaunchcount Total number of launches since install  (only reset if app deleted)  Number  "3"  lifecycle_totalsecondsawake  Total number of seconds your app has been in a woken/active state since app install  (only reset if app deleted)  Number  "36" lifecycle_totalsleepcount  Total number of times your app has gone into the background since app install  (only reset if app deleted)   Number  "400" lifecycle_totalwakecount  Total number of launches + wakes since install (only reset if app deleted)  Number   "563" lifecycle_type   Type of lifecycle call String "initial", "launch", "wake", "sleep", "terminate" lifecycle_updatelaunchdate  GMT timestamp of first wake/launch after a version update has been detected  String  "2014-09-08T18:10:01Z" lifecycle_wakecount  Total number of launches + wakes in this version of your app (resets if updated)  Number   "29"     ... View more

The following variables are populated by the Tealium iOS Library as part of the mobile data layer. These variables are included automatically in each tracking call from the library and can now be used in your iQ or EventStream configurations.  Addition variables are available in the Lifecycle Tracking Module for 5.0.x. Variable Name iOS Version Description app_name 1.0+ Application name [any string] app_rdns 3.2+ Reverse DNS Bundle Id/Package ID [ie.com.tealium.sampleApp] app_version 1.0+ Application version [any string] call_type 2.2+ Call type [view/link] carrier 2.0+ Carrier device is currently on [ATT, Verizon, etc.] carrier_iso 2.2+ Carrier iso country code - ISO 3166-1 carrier_mcc 2.2+ Mobile country code - ITU-T Recommendation E.212 carrier_mnc 2.2+ Mobile network code connection_type 1.0+ [wifi, cellular, etc.] device 1.0+ [iphone, ipad, etc.] device_architecture 3.2+ Bit architecture of the device [32, 64, etc] device_battery_percent 4.0+ Whole number percent representation of device's remaining power [20, 50,...] device_cputype 3.2+ Cpu type [arm6, arm7, arm7s, etc] device_ischarging 4.0+ Is the device actively charging [true, false] device_language 3.2+ Two-letter ISO-639-1 language setting identifier [en, ja, etc.] device_orientation 5.0+ Orientation of device at time of call [Portrait, Landscape Left, Landscape Right, Portrait UpsideDown, Face Up, Face Down, Unknown] device_os_version 5.0+ Operating System version on device [7.0] event_name 5.0+ "mobile_link" required by vdata library_version 2.0+ The version of the Tealium library your app has installed link_id 1.0+ (EVENT CALLS ONLY) General event or link title - this could be a button title or an object's Tealium ID [any string] orientation 2.0+ DEPRECATED Orientation of device at time of call [Portrait, Landscape Left, Landscape Right, Portrait UpsideDown, Face Up, Face Down, Unknown] origin 3.2+ Constant that can be used in mapping to distinguish mobile from web implementations [mobile] os_version 1.0+ Operating System version on device [7.0] page_type 5.0+ "mobile_view" constant that can be used in mapping to distinguish mobile view / page changes from mobile or web events - required by vdata platform 1.0+ [iOS, Android, BB10, etc.] screen_title 1.0+ (VIEW CALLS ONLY) General view title [any string] timestamp 2.0+ Timestamp to seconds of event occurrence (ie 2013-07-11T19:57:47Z) [ISO8601 at Zulu] timestamp_local 2.2+ Local Timestamp to seconds of event occurrence (ie 2013-07-11T19:57:47) [ISO8601 without offset] timestamp_offset 2.2+ Local timezone offset of device's location in hours (ie -3) timestamp_unix 2.2+ GMT/UTC Unix timestamp (ie 1373498679) of event occurrence. timestamp_unix_milliseconds  5.4.5+   GMT/UTC Unix timestamp in milliseconds (ie 1373498679123) of event occurrence. uuid 2.0+ (Universally Unique Identifier) Unique for each installation of an app on a device. [any string] visitor_id 5.0+ Tealium-generated visitor_id was_queued 4.1+ Whether this dispatch was queued or batched prior to sending [true/false].   ... View more

This article describes how to enable a profile to be used for a mobile application installation. In this article: Table of Contents Placeholder Prerequisites Your mobile profile is used with an installation of one of the following mobile application platforms: Tealium for iOS Tealium for Android How it Works Profiles in your iQ Tag Management (TiQ) account are configured for use on a website by default. Any profile can be activated for use within a native mobile installation. You can activate an existing profile for mobile use or create a new profile to remotely manage settings and vendor tracking deployed to your mobile application. Create a New Profile for Mobile Use Before you begin, you can optionally create a new profile with a name that indicates the profile is intended for use with a mobile application, for example: "mobile-ios". For additional information about creating a new profile, see Managing Profiles. Activate a Mobile Profile Use the following steps to activate a profile for use on mobile: Log on to TiQ using the profile that you intend for use for your mobile applications. Click Save/Publish in the upper right corner of the screen. The Save/Publish dialog displays. Click Configure Publish Settings in the upper right corner. The Publish Configuration dialog displays. Click the Mobile Library Publishing tab. Click Activate Mobile Library and then click Activate to confirm. Click Save. Save and publish your settings. This profile can now be used with your mobile application integration by referencing the account name, profile name, and publish environment. Standard mobile variables are added to the profile and available to the data layer settings for use with tags and extensions. Configure Mobile Settings Use your mobile profile to adjust the configuration settings that determine the behavior of your mobile installation. Use the following steps to adjust your mobile configuration settings: Log on to TiQ using the profile that you intend for use for your mobile applications. Click Save/Publish in the upper right corner of the screen. The Save/Publish dialog displays. Click Configure Publish Settings in the upper right corner. The Publish Configuration dialog displays. Click the Mobile Library Publishing tab. Mobile publish settings are enabled by default. You can optionally scroll through the mobile publishing settings, as described in the following table, and adjust as needed. Configuration Tag Management Enables mobile tag management in your application for client-side event tracking. utag.js runs in a webview. Tealium Collect Enable native mobile tracking for server-side data management (HTTP calls directly to EventStream). Set to OFF if you enabled Tag Management. Tealium S2S Legacy Set to ON for events and views to be sent via Tealium S2S legacy protocol. Batching Send Batch Data after every (#) event Allows you to set the number of events (size of batch) that must occur before data is sent back. Entering a value of 0 or 1 essentially turns off batching. The default value is set to 1. WiFi Only Sending By enabling ON, events only send when the user's device is connected to WiFi. The default value is OFF. Battery Saver By enabling ON, data is only sent when the device has adequate battery power and is not in power saving mode. iOS: 20% battery and not charging. Android: 15% battery The default value is ON. Data Retention Dispatch Expiration in (#) days Specify how long (in days) the data persists in the application if no data has been sent back. A value of -1 means there is no dispatch expiration. The default value is set to -1. Dispatch expiration is also applied to events queued due to WiFi only Sending or Battery Saver settings. Minutes Between Synchronization The number of minutes between configuration checks (checks occur at launches and wakes). The default value is 15.0. Queue Capacity The number of events and views to store on the device until ready to send. 0 = no offline dispatching -1 = no limit The default value is -1. Debugging Set Debugging Log Level Allows you to enable logging. Select one of the following settings: Default – Sets the log level to match the Environment setting in your configuration. Dev – Log activity, info, warnings, and errors QA – Log info, warnings, and errors Prod – Log errors Silent – Do not log Click Save. Save and publish your settings. The next time your mobile application is loaded, the new configuration is detected and applied. ... View more

This guide describes how to add Tealium to your iOS app to track user activity. In this article: Table of Contents Placeholder Requirements Xcode 7 and higher Compatible with iOS 8.1 and higher For use with iQ Tag Management: Mobile Profile in iQ (see Creating a Mobile Profile) For use with Universal Data Hub: Account enabled for AudienceStream, DataAccess, or EventStream. Installing CocoaPods We recommend using CocoaPods CocoaPods to install the TealiumIOS framework. To do this, add the following dependency to your Podfile: pod "TealiumIOS" Save the file and run the following in your project directory: pod install Use the created .xcworkspace file to continue building your app. If you do not use the .xcworkspace  file, you will not be able to build the app correctly. Carthage If you prefer, you may use Carthage to install the Tealium frameworks: Add the following to your Cartfile binary "https://tags.tiqcdn.com/dle/tealiummobile/tealium-ios-carthage/tealium-carthage.json" Run  carthage update --platform ios   to download and extract the frameworks. Make sure Carthage is properly integrated into your Xcode project, so that the required frameworks are copied automatically at build-time. Remember to strip simulator support as necessary before submitting to the App Store. You can avoid this step by using the "DeviceOnly" builds provided on the GitHub repo, which are also downloaded when using Carthage. Add to Project Manually You can also add Tealium to your project manually following these steps: Add TealiumIOS.framework to your project. Copy framework to project in the resulting dialog box. In the Target go to General > Embedded Binaries and add TealiumIOS.framework . For Swift projects go to the Build Settings > Swift Compiler > Objective-C Bridging Header option and include the file TealiumIOSBridgingHeader.h . Make sure all paths are as expected under Targets > Build Settings. Initializing The Tealium instance must be configured with the following parameters before it will begin tracking: account – the name of your account profile – the name of your profile environment – one of "qa" or "prod" datasource – (optional) the data source key from UDH instance – a unique name for your instance (multiple instances are supported) In the Application Delegate or within a helper class setup method, use the following initialization code for Swift or Objective-C:   Swift // set your account, profile, and environment let tealConfig = TEALConfiguration.init(account: "ACCOUNT", profile: "PROFILE", environment: "prod", datasource: "DATASOURCE") // Initialize with a unique key for this instance guard let tealium = Tealium.newInstanceForKey("INSTANCE", configuration: tealConfig) else { // Any additional failure response here return } Objective-C // import area @import TealiumIOS; // Set your account, profile, and environment TEALConfiguration *tealConfig = [TEALConfiguration configurationWithAccount:@"YOUR_ACCOUNT" profile:@"YOUR_PROFILE" environment:@"prod" datasource:@"DATASOURCE"]; // Initialize with a unique key for this instance Tealium *tealium = [Tealium newInstanceForKey:@"INSTANCE" configuration:tealConfig];  Overriding Log Level Settings The log level is set by default from the publish settings from your iQ account. Use the following Swift or Objective-C examples to override this setting set the logLevel property in the TEALConfiguration instance: Swift // Set the log verbosity to errors only tealConfig.logLevel = .prod Objective-C // Set the log verbosity to maximum [tealConfig setLogLevel: TEALLogLevelDev]; Tracking Views A tracking call should be made each time a user opens or changes a screen in the app. This is easily accomplished in the viewDidAppear method of any View Controller. A view is tracked by calling trackViewWithTitle()  with two parameters: the name of the screen and (optionally) contextual view data, as shown in the following Swift and Objective-C examples:  The screen name value will be populated in the event attribute named  screen_title . Swift // Retrieve instance let tealium = Tealium.newInstanceForKey("INSTANCE") // Basic tealium?.trackViewWithTitle("screenName", dataSources: [:]) // With optional data let optionalData = ["someKey":"someValue"] tealium?.trackViewWithTitle("screenName", dataSources: optionalData) // With optional data let optionalData = ["someKey":["arrayValue1","arrayValue2"]] tealium?.trackViewWithTitle("screenName", dataSources: optionalData) Objective-C // Retrieve instance Tealium *tealium = [Tealium instanceForKey:@"INSTANCE"]; // Basic [tealium trackViewWithTitle:@"screenName" dataSources:nil]; // With optional data NSDictionary *optionalData = @{@"someKey":@"someValue"}; [tealium trackViewWithTitle:@"screenName" dataSources: optionalData]; // With optional array data NSDictionary *optionalData = @{@"someKey":@[@"arrayValue1","arrayValue2"]}; [tealium trackViewWithTitle:@"screenName" dataSources: optionalData]; Tracking Events All non-view activity should be tracked as an event. This is accomplished by calling trackEventWithTitle() with two parameters: an event name and (optionally) contextual event data, as shown in the following Swift and Objective-C example: The event name value will be populated in the event attribute named tealium_event . Swift // Retrieve instance let tealium = Tealium.newInstanceForKey("INSTANCE") // Basic tealium?.trackEventWithTitle("someEvent", dataSources: [:]) // With optional data let optionalData = ["someKey":"someValue"] tealium?.trackEventWithTitle("someEvent", dataSources:optionalData) // With optional array data let optionalData = ["someKey": ["arrayValue1", "arrayValue2"]] tealium?.trackEventWithTitle("someEvent", dataSources:optionalData) Objective-C // Retrieve instance Tealium *tealium = [Tealium instanceForKey:@"INSTANCE"]; // Basic [tealium trackEventWithTitle:@"someEvent" dataSources:nil]; // With optional data NSDictionary *optionalData = @{@"someKey":@"someValue"}; [tealium trackEventWithTitle:@"someEvent" dataSources:optionalData]; // With optional array data NSDictionary *optionalData = @{@"someKey":@[@"arrayValue1", @"arrayValue2"]}; [tealium trackEventWithTitle:@"someEvent" dataSources:optionalData]; Samples and Documentation The following links provide additional information about Tealium sample applications and API documentation. Sample Apps API Documentation Submitting to the App Store The mobile library contains slices which will permit running it in the simulator. Unfortunately, the simulator architecture is not allowed by Apple when submitting to the App Store. When creating your archive, be sure to run one of the following two scripts to strip out the simulator: Daniel Kennett's Strip Framework Script Realm strip-frameworks.sh Change Log For Change Log information, see GitHub. ... View more

AudienceStream is an Omnichannel customer segmentation and real-time action engine. AudienceStream takes the data that flows into EventStream and creates visitor profiles that represent the most important attributes of your customers' engagement with your brand. These visitor profiles are segmented by shared behaviors to create audiences, sets of visitors with common traits. These audiences fuel your marketing technology stack in real-time via connectors. Let's see how it all fits together. Table of Contents Placeholder What is a Visitor Attribute? An Attribute captures information about a visitor's habits, preferences, actions, etc. These attributes can come from websites, mobile apps, or even offline data sources. Attributes can store everything from First Name and Email Address to Last Login Date and Lifetime Total Spend.  The following attribute types are used in AudienceStream: Visitor Attributes capture stateful characteristics and behavioral information about your customers. Examples: Lifetime Value, Favorite Categories, and Login Identifier. Visit Attributes capture details about the current state of the visit. Examples: Device Type, Active Browser Type, Page View Count, or Time On Site. Omnichannel Attributes capture details about offline event and visitor information. Examples: Support Call Duration, In-Store Transactions, or Purchase Reconciliation information. Learn more about using attributes. What is a Visitor Profile? A Visitor Profile is a unified view of a customer across all touchpoints (web, mobile, email, etc.). By using a special attribute called a "Visitor ID", AudienceStream can identify the same customer across many different platforms. A Visitor Profile comprises all the Attributes that describe the behavior and state of that customer's engagement with each of your brands. This Visitor Profile enables the use of powerful strategies for personalization and targeted marketing and are the basis for building Audiences.  What is an Audience? An Audience is a collection of Visitor Profiles that have acquired a shared set of Attributes during their engagement with your brand. An Audience is the target of a real-time action from one of the many integrations (Connectors) available in the AudienceStream ecosystem (e.g. email, online advertising, social, and customer relationship management).  Learn more about  Building an Audience .   What is a Connector? A Connector is a technical integration between Tealium and another online service or API. Connectors are used to take real-time action on an Audience. Learn more about Connectors. Next Steps Want to learn more? Check out Getting Started with AudienceStream.   ... View more

There are three foundations to the iQ Tag Management system: Client-side technology that leverages the speed and reliability of web browsers and the JavaScript language. Globally scaled Multi-CDN to ensure the fastest delivery of files. Over 900 vendor integrations. A Client-Side Approach iQ Tag Management distinguishes itself from other solutions as being a client-side solution. Most tag managers rely on an application server to facilitate the execution of tags in their system. An application server determines which tags to load and how to run them, then sends this configuration back to the browser on every page load. A more scalable and optimized approach is to bypass the application server and provide all the tag configuration logic from a static JavaScript file that can be processed solely by the browser. In iQ Tag Management, your vendor tag configuration and business logic is represented in JavaScript code that resides inside the main client-side library called utag.js. As visitors browse your site, this file is loaded and, within the browser itself (i.e. client-side), determines which additional vendor tags to load and how to send their data. Once these files have been retrieved by the browser they are cached for subsequent page views to optimize network traffic and page performance. About Data Privacy and Tracking The iQ Tag Management solution (utag.js) is a container tag for the purpose of loading other JavaScript files or running custom JavaScript code. The  tags.tiqcdn.com domain does not collect the IP address or any data about the users of the sites where it is loaded. Users that block requests to tags.tiqcdn.com might experience broken site functionality. Only clients who have also implemented the Tealium Collect tag will cause data to be collected by Tealium. To block data collection by Tealium add a filter to block outgoing requests to //collect*.tealiumiq.com . To block data collection by third-party vendors add a filter specific to the data collection endpoint for that service. Additional Reading: Quick start guide to adding iQ Tag Management to your website Understanding the Effects of Tagging on Page Performance A Tag Management Network (mCDN) A CDN is a collection of servers spread around the globe designed to serve content from locations in close proximity to users. However, not all CDN's perform equally. Even within the same CDN, the performance may vary between regions and/or the time of day. Tealium has optimized these variances by building a multi-CDN system that applies real-time monitoring to multiple CDN's to ensure our files are served as fast as possible. 800+ Vendor Integrations We have looked at countless tag vendor solutions and developed turnkey integrations in iQ Tag Management that make adding and setting up tags a breeze. Most tags generally have three types of requirements: settings and options data collection load rules Each time you add a tag in iQ you will go through these same three configuration steps. Behind the scenes of the user interface, our integrations will take care of the complicated specifics of each vendor's tagging code to ensure it runs exactly as expected. This means you are free to focus on the high-level details of when and where to load tags and what data they should receive while iQ handles the technical details of the vendor's requirements. Additional Reading iQ Tag Marketplace Install Tealium for JavaScript (Web) ... View more

If you're new to Tealium and Tag Management this overview will prepare you to start working with iQ Tag Management. We introduce the core concepts of tag management and then provide a detailed walk-through of the product interface.  Before you begin, here is a quick video overview of tag management: What is a Tag? A tag is a term used in the web technology and analytics industry to describe a small snippet of code that is placed on a website for the purpose of tracking important visitor activity. Tags are also known as tracking pixels or web beacons. Tags are commonly used by marketers to measure the effectiveness of online advertising, email marketing, site personalization, and conversion tracking (among many other uses). This is accomplished via data sharing wherein contextual information from the webpage is passed to the tag in accordance with the vendor's formatting requirements. The most common methodology for implementing a tag onto a website is to use a small snippet of JavaScript code. What is Tag Management? Tag Management is a system for managing the configuration, testing, and release of third-party vendor tags to a digital property. This approach replaces the hard-coded tags on your site with a single container tag. Once this tag is in place you have full control over adding, removing, and updating the tags on your site directly from the iQ Tag Management interface. What is a Data Layer? Once you realize that tags are simply a means for collecting and sending data between your digital property and your vendor, it becomes clear that data is the most important component in the system. The Data Layer represents this data in a vendor-neutral and user-friendly format that is aligned with your organization's business goals. The Data Layer is modeled to capture the vast amounts of customer interaction data that flow from your digital properties. The Data Layer then powers your third-party vendor integrations and becomes the foundation for your customer data initiatives. ... View more

This guide explains how to track events using utag.link() and reviews some common strategies for implementing a global and scalable event tracking solution.  The goal of event tracking is to collect information about your visitors’ interactions within a page. While page view tracking gathers information about the navigation path a visitor takes, event tracking monitors what visitors do in-between navigation steps. In this article:   Table of Contents Placeholder Overview Events are interactions a user has with your site that occur after the page has loaded. Examples of these interactions are: form field selections, file downloads, expanding menus, video plays, and many more. We recommend using a reserved variable in the data layer named tealium_event  to uniquely identify each type of interaction that is tracked on the site. The values set for this variable will be plain-English descriptors of the events being tracked. This variable will be used throughout Tealium iQ to configure Load Rules, Extensions, and Data Mappings. Additional data related to the event should be included in the data layer of the tracking call. utag.link() This method tracks non-page views, page interactions, and other dynamic events that might occur on a page. Calling this method will trigger the corresponding event tracking functionality within your configured vendor tags.  Best practice is to use the variable   tealium_event   to uniquely identify events. Function Definition utag.link(data_object, callback, [uid_array]); data_object Object, optional A data object containing the attributes associated with this specific tracking call. Uses the same format and variable names as the Universal Data Object. callback Function, optional A function to be executed after the tracking call has completed. uid_array Array, optional An array of tag IDs. Will limit the tracking call for the vendor tags specified by the UID's in this array. Example of an "Add to Cart" event, without a callback function, tracked by all tags:  utag.link({ "tealium_event" : "cart_add", "product_id" : ["12345"], "product_name" : ["Lucky Shirt"], "product_quantity" : ["2"], "product_price" : ["12.99"] }); Event Names The suggested tealium_event  values include, but are not limited to: Value of tealium_event Event cart_add Add to Shopping Cart cart_remove Remove from Shopping Cart cart_empty Empty Shopping Cart cart_view View Shopping Cart (Modal) user_register User Registration Complete user_login User Login user_logout User Logout email_signup Newsletter Email Signup social_share Share a Link on a Social Site Use the Tealium Events extension to set up more standard events. Any additional data related to the event should be included in the same tracking call. Example: utag.link({ "tealium_event" : "social_share", "social_network" : "LinkedIn", "shared_link" : "https://tealium.com/" }); Previous Versions The behavior of the utag.link() call changed in the following versions of utag.js: Version 3.36 Calls to utag.link() will now reevaluate load rules and load new tags. Version 4.26 All page data variables are now available to utag.link() calls. Understanding Your Options Just as page view tracking requires a data layer object to give context about which page is being tracked, event tracking also requires a data layer object be included in the tracking calls. For example, the variable utag_data.page_type in the data layer helps distinguish between different types of pages (product, search, cart, etc.) and the variable utag_data.tealium_event  distinguishes between the different events to be tracked (cart_add, newsletter_signup, user_login, etc.). Similarly, as certain data layer variables are only relevant to certain page types (eg. search_keyword on Search pages), only variables relevant to a tracked event are required in the tracking call (eg. social_network  when tracking a social share event). The following options describe the various methods of implementing Tealium’s event tracking into your website. Option #1 - jQuery Extension and HTML5 data attributes The jQuery Extension is used for tracking basic interactions within a page, such as clicking, expanding, ticking, checking, selecting, etc. HTML5 supports data attributes which can be used to associate information to elements in the page. To implement a site-wide custom click tracking solution a global markup strategy should be created to expose the necessary event attributes in the data attributes of the elements to be tracked. An element with data attributes might look like this in the page code: <a href="/logout" data-click_name="Sign Out" data-click_category="header">Log out</a>  These attributes can then be used in the jQuery Extension selector and to set values in your data layer object. Using the "JS Code" option you can dynamically assign the value of a data attribute to a data layer variable. To use data attributes with the jQuery Extension: Use a selector to identify elements with a specific data attribute eg. a[data-click_name] Set a variable using the "JS Code" option to reference a data attribute in the clicked element eg. $(this).data('click_name') Requires a web page with semantic markup. Best Uses: link clicks, button clicks, form field interactions Not recommended for: ajax page flows, form submissions Option #2 - Coded utag.link, utag.view Used for tracking dynamic page content refreshes, ajax pages, modal form submissions or any event that requires a round-trip request/response to the client’s web server to fetch additional data not already present on the page. Best Uses: modal forms, product quick view, single page websites, add to cart from non-product pages Not recommended for: link tracking   Option #3 - Page Data Layer Used when an event occurs at the same time as a new page load. The default page view tracking can perform the event tracking at the same time provided the required data layer variables are present (eg. event_name). For example, in a cart checkout process, when asked to checkout as guest, new customer, or existing customer, if you select “existing customer” and login with correct credentials, the following page load could contain this data layer indicating it is the "Shipping" section of the checkout and that a "user_login" event has occurred:   var utag_data = { "page_type" : "checkout", "page_name" : "Shipping Information", "event_name" : "user_login", "customer_id : "0123456789" }; Best Uses: user login, user registration, “success” pages Not recommended for: modal forms, ajax pages Option #4 - Video Video tracking often requires a custom Javascript code solution. This can be implemented within a JavaScript Code Extension, but still requires coding to the specifications of the video platform’s API.   Current solutions for video tracking: YouTube Video Tracking ... View more