Tealium Learning Center

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_profile=[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

This guide explains how to track page views using utag.view() . Page view tracking gathers information about the navigation path a visitor takes on your site. Each time a web page is loaded, or the main content of the screen is changed, a page view should be tracked. The default installation of utag.js will automatically track page views on the DOM-ready event. Table of Contents Placeholder utag.view() This method tracks page views, virtual page views, and other AJAX page flows. Calling this method will trigger the corresponding page tracking functionality within your configured vendor tags. Things to note: Commonly used for AJAX page flows where the URL does not refresh as the user navigates the site eg. single-page checkout or single-page application. The data layer object declared on the initial page load ( utag_data ) is not re-purposed with these calls. You must explicitly pass a new object to utag.view(). Best practice is to use the variable tealium_event to identify important page view events and   page_type to uniquely identify page templates.   utag.view(data_object, callback, [uid_array]); data_object Object, optional The 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 a "Product Quick View" tracking call, with a callback function, and only tracked by tags "34" and "12": utag.view({ "tealium_event": "product_view", "page_type" : "product_quick_view", "page_name" : "Quick View: Shirts: Lucky Shirt", "product_id" : ["12345"], "product_name" : ["Lucky Shirt"] }, function() { utag.DB("Product Quick View has been tracked"); }, [34, 12] ); Single Page Applications On single page applications where the page loads utag.js only once per visit, you will suppress the automatic page view tracking call to allow your application to make these calls directly. To override the automatic page tracking add this line to your page prior to loading utag.js: window.utag_cfg_ovrd = {noview : true}; Once your application is loaded (and utag.js is loaded) you can trigger utag.view() tracking calls in your page code. These calls would typically be triggered at the DOM-ready event or any event that causes a content view refresh. Read about more useful settings in utag_cfg_ovrd. Important Notes The utag_data object declared on initial page landing is not re-purposed with these calls. If data from the initial page landing needs to be used it will need to be re-declared and passed again in the method call. As o utag.js version 4.36 or later, utag.link calls will load in tags not already on the page. As of utag.js version 4.26, load rules are re-evaluated for both utag.view and utag.link calls. Note: a utag.link call will not bring in a new tag (one that isn't already loaded from initial page load), whereas a utag.view call will. For utag.js versions prior to 4.26, load rules are not executed again during manual utag.view() or utag.link() calls. This means only the tags loaded on the initial page landing are available to be executed. For example, if SiteCatalyst and DoubleClick are the only two tags to run on page landing, these will be the only two tags available to respond to the utag tracking calls. Global and Tag-scoped Extensions are executed during these calls. Pre-loader and DOM Ready extensions will not executed during these calls. ... View more

There are several ways to validate that your utag.js installation is working properly. Begin with Web Companion to verify that the page is loading utag.js correctly, followed by using the Universal Tag Monitor to see that your UDO is populated as expected. Advanced users can then explore the debug output in the browser console to troubleshoot more technical issues.  Table of Contents Placeholder Web Companion Web Companion is a browser tool that allows you to audit your tag configuration, inspect data on your site, and create and test new configurations quickly and easily.  Launching this tool will quickly verify that the utag.js library is loading properly on your site.  Account Information The current account, profile, version, and environment that the page is running is displayed under this tab.  Target Environment The environment detected in the page will be outlined in orange. The currently viewed environment will be highlighted in blue. You may view any of the three environments by clicking the desired button and reloading the page and relaunching Web Companion. NOTE: Allow the webpage to finish loading before restarting Web Companion. Tags & Extensions Tabs This tab will show which Tags loaded and whether they successfully sent requests. The Extensions that are successfully completed will also be displayed. Timers The load and send times of each Tealium JavaScript library are displayed at the bottom of the tab. Saving Changes Changes applied to the profile through the Web Companion are queued at the bottom of the bookmarklet and will not be committed until you click the "Save..." button. If you do not wish to commit a change, you may also remove that change from the queue by clicking on the X button next to the appropriate change. Read the full guide to installing and using Web Companion Universal Tag Monitor The Universal Tag Monitor (or "utag Monitor") provides an easy way to validate your data layer and tracking calls in real-time as you navigate your site. It's similar to Web Companion, but is focused on the data captured by each tracking event within utag.js. The tracking calls made by utag.js are displayed and updated in the tool as you navigate or trigger in-page events.   Read the full guide to installing and using Universal Tag Monitor Debug Mode There is a debug mode in which utag.js will output detailed run-time information to the browser console. To enable this mode open the browser developer tools and run the following command: document.cookie="utagdb=true"; With debug mode activated the browser Console will show information about how utag.js is executing: what events have been triggered, which tags are being loaded, and the state of the UDO as it's passed to each tag. Vendor tags are referenced by numbers, for example "1", "35", "34", and "3" in the above screenshot. These are the UID's associated with each tag from within Tealium iQ. Below is a breakdown of the different output results you see. This is not a comprehensive list as the output will be specific to your implementation. The log output may change at any time due to updates and enhancements. Pre-INIT - Pre Loader scoped extensions are now running utag.loader.RD - data is being read from the page such as the UDO, Meta Data, DOM data, cookies, and JavaScript page variables.  utag.load.INIT - states when the standard utag.js file logic is initiated All Tags EXTENSIONS - states any All Tags scoped extensions are now running utag.loader.INIT: waiting 1 - lists Tags waiting for DOM Ready READY - states the library is ready for DOM Ready to occur WQ - states how many tags are set to wait, e.g. the screenshot above has 4 tags enabled and all 4 are set to wait Attach to head - injecting the script into the source code utag.loader.WAIT - states when the specified tag is loaded into the browser but to wait until DOM Ready to fire the Tags utag.loader.LOAD - states when the tag's u.send function runs, this is what is responsible for sending data to the Tag Sending: 1 - states when the Tag is triggering the call to the vendor SETFORCE:WAIT - states when tags are about fire due do DOM Ready trigger:view - states the type of event that is occurring, either view or link Search the contents of utag.js for "utag.DB" to see where the function is called. ... View more

This guide explains how utag.js and vendor library files are loaded in the page. For a detailed technical breakdown of the order of operations check out Understanding Order of Operations (utag.js). Table of Contents Placeholder Serve Files from CDN All tag configuration and business logic saved in your iQ account/profile is converted to JavaScript code and published to a utag.js JavaScript library specific to your account/profile and hosted on our multi-CDN infrastructure. The CDN is designed to deliver these files to your website as quickly as possible. When the Universal Tag code snippet is executed by your webpage a request is made to the CDN, the file is downloaded into the page and the code is run. As soon as utag.js is loaded on your page it begins executing code to prepare to fire your tags. Build the Data Object In addition to the dynamic data that your site will populate into utag_data , the utag.js library will automatically gather other various data values from the page and combine them into one central data object to be made available to your tags and load rules. The following page elements will be captured: Query String Parameters First-Party Cookies JavaScript Variables Meta Data Elements The final data object will then be used to power your load rules and tags. Evaluate Load Rules Load Rules are precise conditions that determine when to load a tag. Generally made up of one or more conditions, a load rule has to be satisfied in order to load the tag to which it is applied. The full list of variables from the data object will be used to evaluate the load rules and determine which tags will load on the page. Load Rules are JavaScript code evaluated client-side, in the browser. Load Vendor Tags The code needed to load and run a vendor tag is also published to the CDN and stored in a tag configuration file numbered according to the UID of the tag, such as utag.1.js. An HTTP request is made to the CDN from your webpage to retrieve each tag configuration file. While this file contains the settings and configuration for the vendor, it might not contain the vendor's JavaScript file. If so, an additional HTTP request will be made to fetch the vendor's code. These requests are made asynchronously to minimize the impact on the time to render the page. Here is a simple example showing how one tag, Google Analytics, would be loaded into the page: utag.js (tags.tiqcdn.com) - the iQ Tag Management JavaScript library utag.1.js (tags.tiqcdn.com) - the Tealium tag configuration file for Google Analytics analytics.js (www.google-analytics.com) - the Google Analytics JavaScript library You can improve page performance by bundling tags into utag.js to reduce the number of HTTP requests coming from your page. Trigger Vendor Tags Once all tag files are loaded and the DOM Ready event is reached, the tags will be triggered and the relevant tracking beacons will be added to the page. The vendor code runs just as it would outside of Tealium, so the resulting HTTP requests will be easy to identify. For example, Google Analytics is identified in the network requests by two items: the analytics.js script and the collect image pixel. These same network requests will occur even when loading Google Analytics via iQ Tag Management, as seen here: ... View more

This article shows how to add Tealium iQ Tag Management to your website. The installation comprises Tealium's client-side JavaScript library, utag.js, and a data layer object called utag_data. Need a refresher? How iQ Tag Management works In this article:  Table of Contents Placeholder Universal Data Object (utag_data) The Universal Data Object (UDO) is a JavaScript object called utag_data in which dynamic data from your webpage is passed to the Tealium tag. The properties in this object are named using plain-English, vendor neutral terms that are specific to your business.   utag_data should be defined and populated prior to loading the Universal Tag. Example: <!-- Tealium Universal Data Object --> <script type="text/javascript"> var utag_data={ "page_type" : "section", "site_section" : "men", "page_name" : "Men's Fashion | Acme Inc.", "country_code" : "US", "currency_code" : "USD" }; </script> Additional Reading: How the Universal Data Object Works How the Data Layer Works for Websites Universal Tag (utag.js) The utag.js JavaScript library is Tealium's universal tag that replaces third-party tags with a single snippet of code. The utag.js file contains all of the generated code necessary to load third-party tags onto your site. The path to the utag.js file comprises the following attributes: Account - the name of your account in Tealium iQ Profile - the name of the profile within your account ("main" is the default) Environment - one of three default publish environments: dev, qa, or prod <!-- Tealium Universal Tag --> <script type="text/javascript"> (function(a,b,c,d){ a='//tags.tiqcdn.com/utag/[ACCOUNT]/[PROFILE]/[ENV]/utag.js'; b=document;c='script';d=b.createElement(c);d.src=a; d.type='text/java'+c;d.async=true; a=b.getElementsByTagName(c)[0];a.parentNode.insertBefore(d,a) })(); </script> Your specific snippet can be retrieved from the Code Center of your account. Additional Reading: How utag.js works Using utag.sync.js Code Placement The Tealium code is designed to be placed after the opening <body> tag (as opposed to the <head>  tag). This positioning provides the best compatibility with the greatest number of vendors and allows third-party tracking to complete before the visitor navigates to the next page. The utag.js code can be placed anywhere within the <body> , although the top is the preferred location. The sooner the page can begin loading utag.js the sooner your tags will be ready to run when the page has been rendered. Additional Reading: Understanding Order of Operations (utag.js) ... View more

This article shows how to set up the the MyBuys tag within Tealium iQ Tag Management. When using this guide it will be helpful to have your MyBuys Implementation Guide as a reference. In this article: Table of Contents Placeholder Tag Configuration First, go to the Tag Marketplace and add the MyBuys tag to your profile (see How to Add a Tag). After adding the tag, configure the below settings: Client ID: Your MyBuys Client ID. Div ID: The ID attribute of the DOM element on the page where the recommendations should appear. MySite Recommendation Zone: The numeric zone number. Global CSS Path: The default URL to the global MyBuys CSS (if used). Client CSS Path: The URL to the client-specific CSS (if used). Load Rules Load Rules determine when and where to load an instance of this tag on your site. Recommended Load Rule: All Pages. Data Mappings Mapping is the process of sending data from a data layer variable to the corresponding destination variable of the vendor tag. For instructions on how to map a variable to a tag destination, see data mappings. The following tables explain the different page types and events that MyBuys tracks and how the corresponding data is mapped within Tealium iQ. Your Universal Data Object should already contain the page_type and event_name variables. Page Types MyBuys Page Type Tealium Page Type (page_type) Required/optional Home home  Required High Level Category section  Required Leaf Level Category category  Required Product Detail product  Required Search Results search  Required Add to Cart cart_add (event_name)  Required Shopping Cart and Checkout cart, checkout  Required Order Confirmation receipt  Required Sale sale  Optional New Arrivals new_arrivals  Optional Brand Home brand_home  Optional Brand brand  Optional Landing Page landing  Optional My Page account  Optional Product Ratings product_ratings  Optional Email Newsletter Signup email_signup (event_name)  Optional The name of the page_type variable might vary for your implementation. The mapping toolbox makes it easy to connect the Tealium page types to the MyBuys page types. When you map the page_type variable, click on the "Page Types" tab, then enter the values populated in the Tealium UDO and select the corresponding MyBuys page from the drop-down menu. The same type of mapping can be used to track events using the event_name variable. Sample Page Type and Event Name Mapping in Tealium iQ: E-Commerce Map to these destinations for sending ecommerce–specific Data Layer variables. We typically recommend using Tealium's E-Commerce Extension for this purpose. Why? When it is properly configured, the Extension automatically maps your variables to the appropriate destinations for all E-Commerce enabled Tags in your profile. That way you don't have to map those variables over and over for every one of your Tag. If you, however, decide to override any Extension variable, or otherwise your variables are not available to the Extension, you must manually map a data source to its destination using the toolbox. Variables By Page Type These MyBuys page types have the following variables associated with them. If these variables are mapped in the E-Commerce Extension then their values will be passed automatically to the MyBuys tag. Otherwise they will need to be mapped explicitly in the tag configuration. Please note that Tealium variable names may vary. High Level Category MyBuys Variable Tealium Variable Mapping categoryId category_id  Mapped  addItemPresentOnPage product_on_page (Array)  Mapped Leaf Level Category MyBuys Variable Tealium Variable Mapping categoryId category_id  Mapped  addItemPresentOnPage product_on_page (Array)  Mapped Brand Page (Optional) MyBuys Variable Tealium Variable Mapping brandname brand_name  Mapped addItemPresentOnPage product_on_page (Array)  Mapped Product Detail Page MyBuys Variable Tealium Variable Mapping addItemPresentOnPage product_on_page (Array)  Mapped productId product_id (Array)  E-Commerce Product Ratings Page MyBuys Variable Tealium Variable Mapping productId product_id (Array)  E-Commerce Search Results Page MyBuys Variable Tealium Variable Mapping addItemPresentOnPage product_on_page (Array)  Mapped Add to Cart Page/Event MyBuys Variable Tealium Variable Mapping email customer_email (defaults to customer_id)  Mapped (E-Commerce) amount cart_total_value  Mapped optin customer_optin  Mapped addCartItemQtySubtotal cart_product_id, cart_product_quantity, cart_product_price (Arrays)  Mapped Shopping Cart Page MyBuys Variable Tealium Variable Mapping email customer_email (defaults to customer_id)  Mapped (E-Commerce) amount cart_total_value  Mapped optin customer_optin  Mapped addCartItemQtySubtotal product_id, product_quantity, product_price (Arrays)  E-Commerce Order Confirmation Page MyBuys Variable Tealium Variable Mapping email customer_email (defaults to customer_id)  Mapped (E-Commerce) orderId order_id  E-Commerce amount order_subtotal  E-Commerce optin customer_optin  Mapped addCartItemQtySubtotal product_id, product_quantity, product_price (Arrays)  E-Commerce Email Signup Page/Event MyBuys Variable Tealium Variable Mapping email customer_email (defaults to customer_id)  Mapped (E-Commerce) gender customer_gender  Mapped zipcode customer_postal_code  E-Commerce Sample MyBuys Variable Mapping in Tealium iQ: MySite Recommendation Zones MySite Recommendation Zones can be configured by specifying two settings: the DIV ID and the zone number. The DIV ID should reference the "id" attribute of an HTML tag in the page where the recommendations should appear. The zone number will match the numeric zone created for your MyBuys recommendations. It is recommended to have these HTML elements hard-coded onto the page to ensure proper placement. Example: <body> ... <div id="mybuys1"></div> ... </body> To configure multiple zones per page, additional mappings are required for the "divs" and "zones" variables. The values of these variables should be arrays containing a list of DIV ID's and the matching zone numbers. In this example, "mb_divs" and "mb_zones" have been defined as new variables and are set as arrays of their respective values using a Set Data Values extension. The arrays can be populated using the "JS Code" assignment option. Zones can be configured on a page-by-page basis by creating multiple extensions, each with a condition.   Example extension setting multiple zones on the product detail page: Result: // On the product page (when page_type equals "product") b.mb_divs = ["mybuys1", "mybuys2", "mybuys3"] b.mb_zones = ["1", "2", "3"]  Verifying the Tag The MyBuys tag should behave identically inside of Tealium as it would outside of Tealium. The easiest way to verify that the MyBuys tag is working is to inspect the network traffic as the page loads. As Tealium loads and fires the MyBuys tag there will be several requests to the MyBuys servers to fetch the CSS files, the JavaScript code files, and ultimately the final pixel call containing the dynamic attributes. Example Network Traffic of MyBuys Tag (As Seen in Chrome Developer Tools): ... View more

This guide explains the steps to configure Charles to proxy HTTP traffic from your iOS device.  This guide applies to version 3.10 and higher of Charles. This is an updated version of the previous tutorial for Charles version 3.7. Table of Contents Placeholder Configuring Charles Open the Proxy > Proxy Settings... menu. On the Proxies tab, enter "8888" in the HTTP Proxy Port field.   Open the SSL Proxying Settings... menu. On the SSL Proxying tab check the Enable SSL Proxying. Try adding a location of *.* in the location list above.  If your app ceases to function correctly, it's possible that the app is rejecting the self-signed certificate from Charles Proxy. If this happens, disable the wildcard match, and list only the Tealium domains. Recommended domains are: *.tealiumiq.com *.tiqcdn.com Go to Help > SSL Proxying > Install Charles Root Certification a Mobile Device or Remote Browser... Make note of the instructions, specifically the IP address and URL to get the certificate eg. 10.0.2.158 and http://charlesproxy.com/getssl Configuring Your iOS Device Go to Settings > Wi-Fi and connect to the same Wi-Fi network as your computer. Select the active Wi-Fi network details and in the HTTP Proxy section choose the Manual mode. In the Server and Port fields enter the IP address and the port number (probably "8888") from the steps above. Once you save your proxy settings on your iOS device you should receive an alert from Charles on your computer asking you to allow the connection. Click Allow. Installing the Charles SSL Certificate on Your iOS Device On your iOS device, pen Safari and navigate to this URL: http://www.charlesproxy.com/getssl Follow the instructions to install the certificate and allow the access.   More info: http://www.charlesproxy.com/documentation/using-charles/ssl-certificates/   Ensure the device trusts the certificate by going to Settings > General > About > Certificate Trust Settings. If the certificate is not trusted, SSL requests will fail in the proxy.    ... View more