Tealium Learning Center

This article describes how to set up the Adobe Analytics connector in your Customer Data Hub account. In this article: Table of Contents Placeholder Introduction The Adobe Analytics Connector in the Tealium Customer Data Hub uses Adobe's Data Insertion API to send analytics data server-side, in place of using the JavaScript beacon on a web page or mobile app. This reduces the amount of data transmitted from the client-side, and also offers the advantage of being able to pass audience and visitor data from EventStream or AudienceStream to Adobe Analytics. Connector Actions Action Name AudienceStream EventStream Send Analytics Event ✓ ✓ Connector Configuration Use the following steps in the interface to configure the Adobe Analytics connector: Go to the Connector marketplace and add the Adobe Analytics connector. Read the Connector Overview article for general instructions on how to add a connector. In the Title field, enter a title for the connector. In the Data Insertion Domain field, enter the domain for your Adobe Analytics data collection servers. For example, namespace.122.2o7.net . In the Report Suite ID field, enter your Report Suite ID. This is the Report Suite used to submit the data. To send data to multiple destinations use a comma-separated list of report suites. This value can also be set with a data mapping. In the Notes field, enter any relevant notes about this connector. Click Next. You are now on the Actions tab. From the Actions drop-down list, select "Send Analytics Event" from the drop-down list and configure the following parameters: Group Description Event Parameters See "General Attributes" below Auto-mapping of Lifecycle Event Attributes for Mobile Data-sources Check this checkbox to automatically map values from the Event Parameters section to Adobe data elements. Auto mapping only applies to Mobile EventStream App Lifecycle only. For more information see Adobe Analytics Connector Lifecycle Mappings Context Data Specify keys using the dot format. For example "my.a". Multiple key-value pairs can be specified. eVars Specify the event eVars by mapping an attribute to a number. For example: Map event_count to 1 for eVar1. Valid range is 1 through 100, 250 for Premium Accounts Hierarchy A hierarchy string. Select from 1 through 5. List A list of values that are passed into a variable, then reported as individual line items for reporting Select from 1 through 3. Requires Array type in data layer. Tealium will format the data correctly to be passed along Properties Analytics property name. Specify the name by mapping an attribute to a number. For example: Map lifetime_value to 1 for prop1. Events Specify a list of events, or a comma-separated custom value. see Adobe Analytics Configure Events Implementation Event Mapping Map a potential value contained in the Events Array (configured above) to the Adobe Analytics Custom Event name. For example, registration to event3 would replace "registration" with "event3" in the event payload. Event Values Specify values for Counter , Numeric , and Currency events. To specify an event, use a number. As an example, 1 will be sent over as event1 . Products Specify product attributes (Id, Category, Quantity, Price) All arrays must be equal-sized and order-aligned For additional information, see Adobe Analytics Product Implementation Product eVars Specify product eVars values. All arrays must be equal-sized to those in the Product section. Empty values will be ignored. Specify eVar mappings with a number. As an example, 1 will be mapped to eVar1 . Product Events Specify product event values. All arrays must be equal-sized to those in the Product section. Empty values will be ignored. Specify event mappings with a number. As an example, 1 will be mapped to event1 . Click Save. Save and Publish your changes. General Attributes For a full reference of all attributes, including details on exactly what each field should contain, see Adobe's API documentation and the Visitor & Experience Cloud IDs section of this article. Report Suite IDs Specify a report suite ID, which will override any value previously entered in the Connector Configuration UI. If you do not need to override that value, you can leave this field blank. You can use either a data layer variable, or a "Custom Value". If you wish to send data to multiple report suites, you may use a comma-separated list. This will overwrite the value defined in the Configuration Tab Specifies the report suites where you want to submit data. Contained in the URL If specifying Data Layer attributes, use simple attribute types per row. We will format the data correctly to be passed along Map From Map To Notes Sample Connector Output Customer Data Hub attribute containing a persistent visitor ID, e.g. tealium_visitor_id visitorID* Ensure that this is a visitor-level persistent value. Example: Tealium Visitor ID <visitorID>01619ea9a91a001af7e29b75797104079005c07101008M</visitorID> Customer Data Hub attribute containing a page name/title pageName String value <pageName>Homepage</pageName> Customer Data Hub attribute containing the current URL (e.g. built-in "Current URL" attribute) pageURL String value <pageURL>http://www.tealium.com</pageURL> Customer Data Hub attribute containing the Adobe Experience Cloud ID marketingCloudVisitorID* Usually retrieved via the Visitor API JavaScript tag. Implemented in iQ Tag Management. <marketingCloudVisitorID></marketingCloudVisitorID> Customer Data Hub attribute containing the link name linkName String value. Example: tealium_event <linkName>Buy Now</linkName> Customer Data Hub attribute containing the URL of the link clicked linkURL String value <linkURL>https://www.tealium.com/products/widgets/buynow\</linkURL> Customer Data Hub attribute containing the order ID purchaseID String value. E-commerce Order ID <purchaseID>ORD12345</purchaseID> Customer Data Hub attribute containing the document referrer referrer Recommend using built-in "Referring URL" attribute. <referrer>https://www.tealium.com/shop\</referrer> Customer Data Hub attribute containing the timestamp from the time the event occurred timestamp Optional. Unix epoch seconds or ISO-8601 format. Do not map if your report suite is not explicitly configures to accepts timestamped hits. For more information, see the Timestamp Implementation Guide. <timestamp>1519207951063</timestamp> Customer Data Hub attribute containing the IP address of the visitor ipaddress To use this optional attribute, you must have enabled the Visitor IP attribute in your account. Contact your account manager if you need this feature. <ipaddress>127.0.0.1</ipaddress> Customer Data Hub attribute containing the user agent of the browser/device userAgent Recommend using the built-in User Agent attribute in Customer Data Hub <userAgent>Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.167 Safari/537.36</userAgent> Customer Data Hub attribute containing the transaction ID for a custom event (not order ID) transactionID This is not the same as purchaseID. See the Adobe Analytics documentation for details. <transactionID>CMPSUMMER18</transactionID> Link Type This field is used for link tracking, and allows setting of a Link Type. Map From Map To Description Example Sample Connector Output Select any attribute from the drop-down list or enter custom value Link type: "d" - Download Link "e" - Exit Link "o" - Custom (other) Link Sends a Link Type to Adobe Analytics only if the attribute selected has a value* Map: (Custom Value): "true" to "o" <linkType>o</linkType> If the attribute selected has a value of null , undefined or "" (empty string), the Link Type will not be set on the outgoing request. Context Data Context Data may be used as a more user-friendly alternative to props and eVars. You can map any event attribute or visitor attribute to Context Data variables in Adobe Analytics. Context Data variables may have any name, but is is an Adobe best practice is to prefix all variables with a unique key, such as your company name. Some variables are reserved and may only be used for predetermined functionality, such as Lifecycle Metrics; these variables are prefixed with " a. ". Map From Map To Description Example Sample Connector Output Select any attribute from dropdown, or enter custom value companyname.someproperty Maps a defined Customer Data Hub attribute to a Context Data attribute Map: (Customer Data Hub Attribute) Campaign Name to "tealium.productColor" <contextData><tealium.productColor>Red</tealium.productColor></contextData> Analytics eVars This field is used to map Customer Data Hub attributes to eVars. eVars must be specified using the word "eVar" (not case-sensitive), plus the number of the eVar, e.g. "eVar11". Valid range is 1 through 250. Map From Map To Description Example Sample Connector Output Select any attribute from dropdown, or enter custom value eVarX, where X is an integer in the range 1 - 250 Maps a defined Customer Data Hub attribute to an eVar in your analytics reports Map: (Customer Data Hub Attribute) Campaign Name to "eVar75" <eVar75>Summer2018</eVar75> Analytics Property Name (s.props) This field is used to map Customer Data Hub attributes to props. Props must be specified using the word prop , plus the number of the prop, e.g. "prop4". Valid range is 1 through 75. List props are supported, but these require prior configuration in your Adobe Analytics Report Suite admin interface. Map From Map To Description Example Sample Connector Output Select any attribute from dropdown, or enter custom value propX, where X is an integer in the range 1 - 75 Maps a defined Customer Data Hub attribute to an prop in your analytics reports Map: (Customer Data Hub Attribute) Link Name to "prop4" <prop4>Buy Now</prop4> Events (s.events) Events allow you to measure how frequently a particular event is occurring on your website or in your app. The events variable is a comma-separated string listing all the events that should be counted for a particular analytics event. Both predefined events and custom events are sent in the same string. In the Adobe Analytics connector, the following two methods are used to specify events: Map an array value containing a list of event names that has been populated elsewhere (e.g. an extension in iQ Tag Management, an Enrichment, or directly in your data layer). Map From Data Type Example Input Sample Connector Output Customer Data Hub attribute representing a list of events Array ["event1", "event5", "event9"] <events>event1,event5,event9</events> Specify an array of string values which map to specific event numbers, and specify the event number mappings in the "Custom Event Mapping" section as follows: Map From Map To Example Event Array Example Input Sample Connector Output Custom text value containing a string to look up in the Events array Name of event to trigger, e.g. event8 ["newsletter_registration", "homepage_viewed"] "newsletter_registration" <events>event8</events> (because string "newsletter_registration" appeared in the events array) Event Value Mapping This field allows numerical values to be assigned to events. This field is not correlated to the "Custom Event Mapping" field; that is, if "event2" is specified in the "Custom Event Mapping" and is also specified as a "Value" event, it would be included in the event variable twice - once with no value, and once with. Map From Data Type Map To Example Input Sample Connector Output Attribute representing a numerical value Number eventX, where X is the number of the event Map "9" to "event5" <events>event5=9</events> Event Serialization Configure event serialization by mapping an attribute that contains the event ID to a number that specifies the event. For example, mapping "ABC123" to "2" sends "event2=ABC123". Map From Data Type Map To Example Input Sample Connector Output Attribute representing an event ID String The event number Map "ABC123" to "1", Map "ABC123" to "2" <events>event1=ABC123,event2:ABC123</events> Products The Products variable is used wherever it is necessary to capture e-commerce information about one or more products on a particular page (Category, Product ID, Price, Quantity). Only Customer Data Hub attributes with Array data types may be used to populate the Products variable. All arrays must be equal in length (i.e. if there are 5 products on the page, Product ID, Quantity, Price, and Category must all be 5 elements in length). Map From Data Type Map To Example Input Data Sample Connector Output Customer Data Hub attribute representing Product Category Array Products Category ["Shoes", "Shirts"] <products>Shoes;;;,Shirts;;;</products> Customer Data Hub attribute representing Product ID Array Products ID ["ABC123", "EFG234"] <products>;ABC123;;,;EFG234;;</products> Customer Data Hub attribute representing Quantity Array Products Quantity ["1", "2"] <products>;;1;,;;2;;</products> Customer Data Hub attribute representing Price Array Products Price ["149.99", "79.80"] <products>;;;149.99,;;;79.80</products> Product Event Value Mapping This field allows a custom conversion event to be assigned to each product in the Products variable, and a numerical value to be assigned to each event. If a "simple" variable is mapped (singular value, or custom text value), then the same value is applied to all products in the list. If a list (array) value is mapped, then the array must have the same length as the rest of the product arrays, and each item in the array will have a different value (according to its position in the array). For these examples, assume the following product arrays are present as event attributes: Product Category: ["Footwear", "Apparel"] Product ID: ["Running Shoes", "T-Shirt"] Quantity: ["1", "1"] Price: ["99.99", "49.99"] Map From Data Type Map To Example Input Value Sample Connector Output Custom text value containing a numerical value String Name of event to trigger, e.g. event8 "9.99" (custom value) <events>event8</events><products>Footwear;Running Shoes;1;99.99;event8=9.99,Apparel;T-Shirt;1;49.99;event8=9.99</products> Customer Data Hub attribute representing array of numerical data Array Name of event to trigger, e.g. event12 ["1.99", "4.99"] <events>event8</events><products>Footwear;Running Shoes;1;99.99;event12=1.99,Apparel;T-Shirt;1;49.99;event12=4.99</products> Product Merchandising eVars This field allows eVars to be assigned to each product in the Products variable. These work in the same way as the "Product Event Value Mapping" field, detailed above. Map From Data Type Map To Example Input Value Sample Connector Output Custom text value containing an eVar value String Name of eVar to trigger, e.g. eVar4 "my_custom_value" <products>Footwear;Running Shoes;1;99.99;event8=9.99;eVar4=my_custom_value,Apparel;T-Shirt;1;49.99;event8=9.99;eVar4=my_custom_value</products> Customer Data Hub attribute representing array of eVar values (e.g. Product Color) Array Name of eVar to trigger, e.g. eVar6 ["red", "green"] <products>Footwear;Running Shoes;1;99.99;event8=9.99;eVar6=red,Apparel;T-Shirt;1;49.99;event8=9.99;eVar6=green</products> Hierarchy Data Page Hierarchy helps to classify a page within your site/app's navigation structure. There are five (5) available slots: hier1 - hier5. The only supported Customer Data Hub attribute type that can be used as a hierarchy var is an Array. Map From Data Type Map To Description Example Sample Connector Output Select any attribute from dropdown, or enter custom value Array hier1 - hier5 (drop-down selection) Maps a defined Customer Data Hub attribute in Array format to a specified hierarchy var in Adobe Analytics Map: (Customer Data Hub Attribute) Page Classification to "hier1" <hier1>Article</hier1> List Data List Variables are delimited strings containing multiple values, and are often used for attribution purposes. A maximum of 3 list variables is available for each Report Suite. The only supported Customer Data Hub attribute type that can be used as a list var is an Array. Map From Data Type Map To Description Example Sample Connector Output Select any array attribute from dropdown Array list1, list2, list3 (dropdown selection) Maps a defined Customer Data Hub attribute in Array format to a specified list var in Adobe Analytics Map: (Customer Data Hub Attribute) Referrer List to "list1" <list1>google.com</list1> Visitor and Experience Cloud IDs See the Adobe Analytics documentation on Visitor IDs, and the order of preference in the event that multiple IDs are provided. Use Case 1: No prior Adobe Analytics implementation If this will be a brand new Adobe Analytics implementation, 100% server-side, you may use your own unique visitor ID, and pass it to the visitorID attribute in the connector. You will need to decide what constitutes a suitable visitor ID, within the constraints set out by Adobe. Use Case 2: Migrating from existing Adobe Analytics client-side JavaScript If you are migrating from a JavaScript-based Adobe Analytics tag to the server-side connector, you will need to keep a consistent visitor ID to avoid "losing" visitors when/if you migrate fully. You will also need to migrate the visitor IDs if you are implementing the Adobe Analytics Customer Data Hub connector as a secondary collection mechanism (where you are still using the JavaScript tag on your web pages or in your apps as the primary collection mechanism). Use the following steps to migrate from existing Adobe Analytics client-side JavaScript, as described in this use case: Follow these instructions to configure the Adobe Experience Cloud ID tag and set up the tag in iQ Tag Management. In this step, you will store the Adobe visitor IDs in a first-party cookie. This will ensure that the value is transmitted to the Customer Data Hub on each hit, without needing to re-request the value for the duration of the session. In iQ Tag Management, go to the Data Layer tab, and create two (2) new First Party Cookie variables called utag_main_adobe_mcid and utag_main_aa_vid . You may rename these variables if you wish, but be sure to retain the "utag_main_" prefix, which will save cookie space by stacking into the utag_main cookie. If you rename the variables, you will need to also update the JavaScript snippet below Create a new JavaScript Code extension, scoped to the Adobe Experience Cloud ID Service tag, and paste in the following code: if (typeof vAPI !== "undefined") { vAPI.getInstance(u.data.adobe_org_id, function (visitor) { var mcID = visitor.getMarketingCloudVisitorID(), analyticsID = visitor.getAnalyticsVisitorID(), sessionExpiry = ";exp-session"; // store Adobe IDs for the session duration if (!mcID) { // something went wrong - the visitor IDs could not be retrieved utag.DB("MCID could not be returned"); } else { utag.loader.SC("utag_main",{"adobe_mcid" : mcID + sessionExpiry, "aa_vid" : analyticsID + sessionExpiry}); // optionally, trigger an empty utag.link call to trigger sending the cookie values to UDH // if utag.track call is omitted (default), values will be sent on the next utag.link or utag.view call anyway // utag.track is used to avoid calling other 3rd party tags; only the collect tag should respond // utag.track("adobe_vid_updated", {}); } }, u.clearEmptyKeys(u.data.config), u.data.customer_ids); } This creates a callback to the Adobe Visitor ID service which will be called when the visitor ID(s) have been successfully retrieved from Adobe's servers, and stores the Visitor ID and Experience Cloud ID in Tealium's own first-party cookie (utag_main). The cookie will expire at the end of the session in case the Visitor ID gets updated in future. If you wish to make the cookie persistent (non-expiring), you could set sessionExpiry to "" in the above code. Add a condition to the JavaScript extension "utag_main_adobe_mcid is not defined AND utag_main_aa_vid is not defined ". This prevents the code from running again during this session. Configure the Customer Data Hub for AudienceStream and EventStream. AudienceStream Configuration If you have AudienceStream, you may store the Adobe Visitor ID and Experience Cloud ID as visitor-level string attributes. Do not store them as Visitor ID attributes. For any actions triggered by an audience event, you may then map the new attribute to visitorID and marketingCloudVisitorID in the connector configuration. EventStream Configuration If you only have EventStream, you do not have the ability to store visitor ID variables, which is why we stored the value in a cookie. If you have already published your iQ Tag Management configuration from the previous step to Prod, you will find the new utag_main_adobe_mcid and utag_main_aa_vid values already present in your Event Attributes. If you have not published to Prod, you may manually add the event attributes, using the First Party Cookie string attribute type. Once you have defined these attributes, you may now choose them in the Adobe Analytics connector and map them to marketingCloudVisitorID and visitorID , respectively. Debugging Common Issues To test the connector, we recommend using the Trace tool. While running a trace, look for the "HTTP Request Body" field, which will show the formatted XML that was sent to Adobe. You can compare the XML output to the "Sample Connector Output" fields in the above tables to verify the output. Look for any errors in the response code being returned from Adobe. Anything other than HTTP Response Status: 200/Successful indicates that there was an error with the request. The full URL structure for the Data Insertion API follows the format http://namespace.112.2o7.net/b/ss//6 . Note that the double forward slash is intentional and valid (in the JavaScript Adobe Analytics implementation, the Report Suite ID would reside here). /6 indicates that an XML payload is being transmitted, and the reportSuite value is sent as part of the XML payload. This is the value you will see when running a Trace session. You do not need to enter the full URL value into the connector configuration; Tealium auto-generates the URL based on the Data Insertion Domain value. You will only see the full URL when running a Trace session. For your specific implementation, you may have a different value for the Data Insertion Domain (e.g. sc.omtrdc.net ), but the namespace should always precede the domain (e.g. namespace.sc.omtrdc.net ), except where you have your own first-party tracking domain (e.g. smetrics.acme.com ). ... View more

Introduction The Android operating system provides each device with a user-resettable "Ad Identifier" (a.k.a. ADID) that can be used to identify an individual device's interaction with adverts displayed via ad networks, and can help companies to measure how effective their advertising spend has been. How Tealium can help To take the burden away from your app developers, Tealium has built a module that integrates with our standard Android library (version 5.2+), which automatically collects the ad identifier when available, and makes the data available as a standard variable for you to use with your tags. Dependencies This module depends on the Google Play Services Ads SDK, and will not function if the SDK is not present in your app. It was built against SDK version 9.4.0, but should function with older and newer versions without issue. Instructions Option 1: Manually add dependency Download the AdIdentifier file from https://github.com/Tealium/tealium-android/tree/master/Support/AdIdentifier In the project's root build.gradle, make sure you have the following: allprojects { repositories { jcenter() flatDir { dirs 'libs' } } } Include in your app's "libs" directory, and add the following to your project module's build.gradle: dependencies { compile(name:'tealium-5.5.4', ext:'aar') // only required if you do not already have this reference compile(name:'tealium.adidentifier-1.1.0', ext:'aar') compile(name:'tealium.lifecycle-1.1.2', ext:'aar') // only required if you do not already have this reference and require lifecycle tracking } Option 2: Maven Dependency In your project's root gradle file, add the following maven repository: maven { url "http://maven.tealiumiq.com/android/releases/" } In your project module gradle file, add the following maven dependency: dependencies{ compile 'com.tealium:library:5.5.4' //only required if you do not have this reference compile 'com.tealium:adidentifier:1.1.0' compile 'com.tealium:lifecycle:1.1.2' //only required if you do not already have this reference and require lifecycle tracking } In the same block where you instantiate the Tealium library (after instantiating Tealium), add the following calls: // import the Tealium AdIdentifier module in the import section import com.tealium.adidentifier.AdIdentifier; // context to pass to AdIdentifier module Context mContext = this; … // substitute the example instance name here with the same instance name you used when initializing the Tealium library private static final String TEALIUM_INSTANCENAME = "teal"; // call this to store the referrer as Persistent data - recommended AdIdentifier.setIdPersistent(TEALIUM_INSTANCENAME, mContext); // call this to store the referrer as Volatile data (reset at app restart/terminate) - not recommended in most cases AdIdentifier.setIdVolatile(TEALIUM_INSTANCENAME, mContext); Deleting the stored AdIdentifier information (not usually required) To delete the stored Ad Identifier string, you can call the standard methods provided by the Tealium library to remove variables from persistent or volatile storage. The key name for the variable is exposed by the TealiumAdIdentifier class. Here's an example to remove the stored Ad Identifier from both persistent and volatile data. This code will have no effect and will not throw an error if the variable doesn't already exist. // import the Tealium AdIdentifier module in the import section import com.tealium.adidentifier.AdIdentifier; … private static final String TEALIUM_INSTANCENAME = "teal"; final Tealium instance = Tealium.getInstance(TEALIUM_INSTANCENAME); // remove from persistent data store instance.getDataSources().getPersistentDataSources().edit().remove(AdIdentifier.KEYNAME).apply(); // remove from volatile data store (session only) instance.getDataSources().getVolatileDataSources().remove(AdIdentifier.KEYNAME); Caveats and warnings If the user has not allowed access to the Ad Identifier, the module will set the "google_adid" variable to the string "Ad Tracking Disabled". You should handle this in your Tealium IQ/AudienceStream configuration to ensure you pass the correct/expected data to your 3rd party technology vendors. Please ensure you have already included the Google Play Services Ads SDK in your app. See here for instructions: https://developers.google.com/android/guides/setup ... View more

Adobe Analytics has the ability to track Application Lifecycle events. The Tealium mobile libraries each have an optional module available to support this feature, which automatically generates the required data for Adobe Analytics. In the Tealium iQ Adobe AppMeasurement tag, the following variables are mapped by the tag template if the check box to turn on automatic mapping is selected. In the EventStream connector, ensure that you are using the latest connector with the "Send Analytics Event" action, otherwise you will need to manually add the mappings listed in the following table. The following table provides a list of Tealium variables by event attribute name and the corresponding Adobe variable name for mapping Customer Data Hub ContextData. For each item, a description, data type, and example is provided. Tealium Variable/ Event Attribute Name Adobe Variable Name (Customer Data Hub ContextData mapping name) Description Data Type Example lifecycle_diddetect_crash a.CrashEvent Was a crash detected during this launch/wake event. Populated only if true. Boolean true lifecycle_dayofweek_local a.DayOfWeek Local day of week that call was made - 1=Sunday, 2=Monday, etc.) Number 13 lifecycle_dayssincelaunch a.DaysSinceFirstUse Days since first launch in integer increments Number 23 lifecycle_dayssinceupdate a.DaysSinceLastUpgrade Days since the last detected app version update in integer increments Number 46 lifecycle_dayssincelastwake a.DaysSinceLastUse Days since last detected wake in integer increments Number 1 lifecycle_firstlaunchdate_MMDDYYYY a.InstallDate GMT Timestamp formatted as MM/DD/YYYY String 01/18/2012 lifecycle_hourofday_local a.HourOfDay Local hour of day that call was made (24 hour format) String true lifecycle_isfirstlaunch a.InstallEvent Only present if call is very first launch/wake call String true lifecycle_isfirstlaunchupdate a.UpgradeEvent Only present if call is first launch/wake after a detected updated Boolean true lifecycle_isfirstwakemonth a.MonthlyEngUserEvent Only present if call is first launch/wake of the month Boolean true lifecycle_priorsecondsawake a.PrevSessionLength 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_totalwakecount a.Launches Total number of launches + wakes since install (only reset if app deleted) Number "563" lifecycle_type a.LaunchEvent if lifecycle_type == "launch" Type of lifecycle call String "launch", "wake", "sleep" device (obj-c/android) or model_name (swift) a.DeviceName Device model String iPhone 7 Plus carrier (obj-c/android) or network_name (swift) a.CarrierName Network carrier name String Verizon device_resolution a.Resolution Screen Resolution String 1080x1920 resolution Screen Resolution String 1080x1920 app_id a.AppID App ID String Digital Velocity 1.0 device_os_version (obj-c/android) or os_version (swift) a.OSVersion Operating system version String 11.1 Vendor Documentation Adobe Documentation: Lifecycle Metrics ... View more

Purpose Adds the user-resettable advertising identifier (IDFA) to each tracking call and optionally implements the Apple Search Ads API to gather attribution information (see [[external]: Apple Search Ads](https://searchads.apple.com/v/advanced/help/pdf/attribution-api.pdf for details)). Supported Platforms iOS Installation CocoaPods Framework will be auto-instantiated, so long as the pod is installed. Depends on TealiumCore pod. No additional import statements necessary besides import TealiumSwift . pod 'tealium-swift/TealiumAttribution' Carthage Framework will be auto-instantiated, so long as it is compiled into your app (included in "Embedded Binaries"). Depends on TealiumCore . No additional import statements necessary. TealiumAttribution.framework External Dependencies UIKit, AdSupport, iAd Recommended Usage Usage of this module is optional. Please take the time to read about its functionality and decide if you really need it, as it introduces additional dependencies. Additionally, you will be required to explain to Apple why you are using IDFA when you submit your app. It should suffice to say that you are using it for attribution purposes. If you do not state that you are using IDFA, Apple will reject your app (see [external]: IDFA Usage). If you choose to exclude the module, the variables listed below will not be included in tracking calls. Included Variables The following variables will be transmitted with each tracking call while the module is enabled: Variable Name Description Example Value device_advertising_id User-resettable advertising identifier (IDFA) 6D92078A-8246-4BA4-AE5B-76104861E7DC device_advertising_vendor_id Unique ID guaranteed to be the same across all apps on the same device from a single vendor (apps with the same 1st 2 parts of the RDNS bundle identifier e.g. com.tealium or com.acme) 6D92078A-8246-4BA4-AE5B-76104861E7DC device_advertising_enabled Boolean to indicate whether the user has allowed ad tracking. True if ad tracking enabled, otherwise false. Note: if false, the advertising ID will appear as a string of zeroes true ad_user_clicked_last_30_days* True if user clicked on a Search Ads impression within 30 days prior to app download. true ad_user_date_clicked* Date and time the user clicked on a corresponding ad 2016-12-05T17:31:40Z ad_user_date_converted* Date and time the user downloaded your app 2016-12-05T17:31:40Z ad_org_name* The organization that owns the campaign the corresponding ad was part of. OrgName ad_campaign_id* The ID of the campaign the corresponding ad was part of 1234567890 ad_campaign_name* The name of the campaign the corresponding ad was part of CampaignName ad_group_id* The ID of the ad group the corresponding ad was part of 1234567890 ad_group_name* The name of the ad group the corresponding ad was part of. AdGroupName ad_keyword* The keyword that drove the ad impression which led to the corresponding ad click. Keyword * Note: these variables are only enabled if Search Ads has been explicitly enabled in the TealiumConfig object. These variables will only be retrieved from Apple's servers once during the app's lifetime, but they will be stored as persistent variables so they are available on future app launches. Future Improvements Update IDFA functionality to have a more robust retry mechanism if IDFA retrieval fails the first time (documented Apple limitation). Change Log 1.6.5 No functional changes. Minor code change to import TealiumCore module for Carthage builds. Removed unnecessary code for Swift versions <4.0 (no longer supported due to Xcode deprecation of Swift 3). 1.4.0 "device_advertising_id" has been changed from Identifier for Vendor (IDFV) to Identifier for Advertisers (IDFA). A new variable "device_advertising_vendor_id" has been added, which contains the IDFV. Added support for Apple Search Ads API. If this module is implemented, Tealium will collect attribution information from the Apple Search Ads API. ... View more

Swift is Apple's newest programming language, designed as a replacement for Objective-C, which was originally the main programming language available across all Apple's platforms (iOS, tvOS, watchOS, macOS). Swift brings a host of improvements and is designed from the ground up to be a safer environment in which to write apps, resulting in better-performing and more robust code, and a better end-user experience. App vendors are increasingly migrating to Swift to take advantage of these new features. To simplify using Tealium with Swift, we have created a new library to make it as easy as possible to implement our products in your Swift apps. Swift and Objective-C code can peacefully co-exist and is fully interoperable within the same app, making migration relatively easy. In this article: Table of Contents Placeholder Which Library Should I Use? The Tealium Swift library is fully compatible with apps running pure Swift, Objective-C, or any combination of the two. Since it is the newest and most up-to-date library, we strongly recommend implementing the Swift library if possible. The Objective-C library is still fully supported, but the Swift library will generally be updated faster and have the newest features. Swift additionally has the widest compatibility of all Tealium libraries, and can even support server-side Swift environments. There are some differences between the two libraries. Check the feature comparison table below to decide which one is most suitable to your needs. Memory Footprint and Performance All SDKs will in some way impact the performance and/or memory of your app, which will vary between apps, It can be difficult to measure the exact footprint of a specific SDK. Tealium has measured the Tealium Swift SDK against a baseline of a standard blank iOS Single View apps. These figures may vary for your specific implementation, so use them only as a rough indicator. The following figures were obtained using the Xcode Allocations Instrument: Compiled App Archive (.ipa file) + 3MB Includes all available optional and mandatory/recommended modules Runtime Memory Usage +2 - +2.5MB Collect dispatcher + all other optional/recommended modules +7 - +10MB Tag Management dispatcher (UIWebView) + Collect dispatcher + all other optional/recommended modules Startup Time Approximate time from initialization to completion callback firing is ≈ 0.05 seconds. Which Swift Versions Are Supported? 4.0 and above (Xcode 9.0+) Which Operating System Versions Are Supported? iOS 9.0+ tvOS 9.2+ macOS 10.11+ WatchOS 3.0+ Which Tealium Products Are Supported? Tealium iQ Tag Management Tealium EventStream Tealium AudienceStream Tealium DataAccess Feature Comparison - tealium-swift vs. tealium-ios The Swift library was built from scratch using a completely new codebase to the Objective-C library (https://github.com/Tealium/tealium-ios). There are subtle differences between the two libraries in terms of the current feature set. The following table compares the features of both libraries. If you have requests for new features, you can open an issue on our GitHub page, or contact your account manager. Feature TealiumIOS (Objective-C) Tealium-Swift Description Notes Instance Manager/Multiton X X Enables support for multiple Tealium instances (profiles) running in the same app. May be added to Swift in a future release. Not a widely-used feature of the Objective-C library. Most customers do not need this feature. Auto Tracking / X Automatically tracks UIViews and Events Present in Swift, but will not be added to Objective-C Lifecycle Tracking X X Tracks App lifecycle events. N/A  Tag Management X X Allows use of Tealium iQ through a non-rendered web view N/A  Tealium Collect X X Sends data to Tealium's UDH using a native HTTPS request N/A  Offline functionality/queuing X X Automatically queues events if the device is online, and transmits when the device is online again In the iOS (Objective-C) library, queued events were persisted across app launches. This feature will be added to Swift in the next release. Current functionality is that any queued data is lost when the app is closed (swiped away) by the user. Remote Mobile Publish Settings (MPS) X / Allows remote configuration of certain library settings Planned support in a future release. Current method of configuration is by the TealiumConfig object only, and must be set at compile time. Volatile Data X X Stores data for the current session (until app is terminated) N/A  Persistent Data X X Stores data between app launches N/A  Remote Commands X X Allows triggering of specified native code blocks from Tealium iQ N/A   Apple Search Ads Support / X Adds support for the Apple Search Ads API to collect attribution data automatically Not planning to port to Objective-C Optimizely Experiment Tracking X / Tracks Optimizely experiment data automatically May port to Swift in future. iOS Support X X   N/A  watchOS Support X X   N/A  tvOS Support X X   N/A  macOS Support / X   N/A  CocoaPods Support X X Support for the CocoaPods dependency manager N/A   Carthage Support X X Support for the Carthage dependency manager N/A   Source Code Available / X May assist with debugging N/A  Consent Manager X X Assists with GDPR/privacy compliance N/A  X = Present —  / = Not Available —  P = Partial Support, see Notes column Variable Comparison - tealium-swift vs. tealium-ios See Swift: Variables List for a list comparing the differences between Swift and Objective-C variables. ... View more

Purpose Dispatches tracking calls to Tealium's Universal Data Hub (UDH). In the Objective-C library (GitHub:tealium-ios), the Collect module dispatched events to the main profile by default, unless overridden. By contrast, the Swift Collect module sends data to the profile passed in the TealiumConfig object. Supported Platforms iOS tvOS watchOS macOS Installation CocoaPods Framework will be auto-instantiated, so long as the pod is installed. Depends on TealiumCore pod. No additional import statements necessary besides import TealiumSwift . pod 'tealium-swift/TealiumCollect Carthage Framework will be auto-instantiated, so long as it is compiled into your app (included in "Embedded Binaries"). Depends on TealiumCore . No additional import statements necessary. TealiumCollect.framework Recommended Usage Usage of this module is strongly recommended if you are using Tealium's UDH. As an alternative, if you are using the Tag Management module, you may instead use the Collect tag via Tealium iQ. This may give greater control over the data and events dispatched to the UDH, as you may then use load rules and extensions to manipulate the data prior to dispatch. If you are using the Collect tag via Tealium iQ, please ensure the Collect module is disabled to avoid duplicate tracking requests. Included Variables The following variables will be transmitted with each tracking call while the module is enabled: Variable Description Example Value dispatch_service Static string to indicate which module the tracking call came from collect Public API There are no public API methods for the Collect module. Dispatch successes and failures may be monitored through the Delegate module. Future Improvements No planned changes. Change Log 1.6.5 Minor code change to import TealiumCore module for Carthage builds. Switch to POST request by default. Added TealiumConfig method to switch back to legacy "vdata" dispatch method. Improved URL override methods to give greater flexibility. 1.4.0 Added config method to override collect URL Build 1 Send dispatches to vdata endpoint ... View more

Purpose Allows data variables to be stored on disk, and automatically adds them to each dispatch/tracking call. Please note, this module cannot be used on its own; it can only be used in conjunction with either the File Storage or DefaultsStorage module. Supported Platforms iOS tvOS watchOS macOS Installation The PersistentData module is bundled with both the FileStorage and DefaultsStorage modules. You should choose one of these modules only. CocoaPods Framework will be auto-instantiated, so long as the pod is installed. Depends on TealiumCore pod. No additional import statements necessary besides import TealiumSwift . pod 'tealium-swift/TealiumFileStorage OR pod 'tealium-swift/TealiumDefaultsStorage as required Carthage Framework will be auto-instantiated, so long as it is compiled into your app (included in "Embedded Binaries"). Depends on TealiumCore . TealiumFileStorage.framework OR TealiumDefaultsStorage.framework import TealiumFileStorage OR import TealiumDefaultsStorage // required if you need to store persistent data Recommended Usage Usage of this module is recommended. Included Variables No additional variables are introduced by this module. Public API add Adds variables to the persistent data store add(data:[String:Any]) Parameters Description Example Value data Dictionary of key/value pairs to add to persistent data ["somekey": "somevalue"] // SAMPLE // assuming 'tealium' initialized earlier tealium?.persistentData()?.add(data: ["customer_id":"1234567890-a"]) getData Adds variables to the persistent data store getData() // SAMPLE // assuming 'tealium' initialized earlier let data = tealium?.persistentData()?.getData() deleteData Deletes data for a specific set of known keys from the persistent data store deleteData(forKeys:[String]) Parameters Description Example Value forKeys [String] array of keys to delete. ["somekey", "someotherkey"] // SAMPLE // assuming 'tealium' initialized earlier tealium?.persistentData()?.deleteDate(forKeys: ["customer_id"]) deleteAllData Deletes all data in the persistent data store deleteAllData() // SAMPLE // assuming 'tealium' initialized earlier tealium?.persistentData()?.deleteAllData() Future Improvements No planned changes Change Log 1.6.5 Now bundled by default with DefaultsStorage and FileStorage modules Bug fix for potential memory leak Build 1 Initial release ... View more

The Tealium Swift library is designed around a modular architecture. Modules instantiate themselves automatically if they are present, and retrieve their configuration from the TealiumConfig object you create at initialization time. Disabling unneeded modules TealiumConfig method Before version 1.6.5 of the Tealium Swift SDK, the only way to disable unneeded modules if you were using CocoaPods or Carthage was via the TealiumConfig object, by setting an array of enabled/disabled modules (whitelist/blacklist). In this scenario, all the code was still compiled into your final app bundle, but any disabled modules were deactivated. This method is still supported, but we recommend migrating to one of the other methods below to take advantage of the performance gains associated with compiling less code into your app bundle. You can safely leave the module list enabled on the TealiumConfig object, and simultaneously remove unneeded modules. In the case where you attempt to enable a module, but the code is not present in your app bundle, it will not cause any undesired consequences, but will simply have no effect. Manual install from source code If you are installing the library manually, you may completely remove unneeded/unwanted modules from your project, and they will not be invoked. Carthage When you install with Carthage, you must explicitly import the modules you require. You may import all modules if you prefer, and use the module list, as described above, but your app will be lighter if you only import the modules you need. See Install with Carthage for instructions on including/excluding specific modules. CocoaPods See Install with CocoaPods for instructions on including/excluding specific modules. Module Dependencies All modules have a dependency on TealiumCore. This means installing any of the optional modules would also install TealiumCore automatically. Module List The modules are listed below in priority order (the internal order in which auto-instantiation takes place). Where additional documentation is required/available, this is linked from the module name in the table. Module Name ID Module Priority (Load Order) Module Group Description Supported Platforms Usage Notes ConsentManager consentmanager 50 - Aids GDPR/privacy compliance iOS, macOS, tvOS, watchOS Recommended   Logger logger 100 - Debug logging iOS, macOS, tvOS, watchOs Recommended - Lifecycle lifecycle 175 - Tracks launches, wakes, sleeps, and crash instances. Auto or manually. iOS, tvOS, watchOS Recommended - Autotracking autotracking 300 - Prepares & sends dispatches for most UI, including viewDidAppear, events. iOS, tvOS Not Recommended* - FileStorage filestorage 350 Persistent Storage Adds general persistence capability for any module. Replaces the Defaults Storage module. Backed by NSKeyedArchiver iOS, macOS, watchOS, tvOS Recommended*   DefaultsStorage defaultsstorage 360 Persistent Storage Adds general persistence capability for any module. Backed by UserDefaults iOS, tvOS, watchOS, macOS Recommended*   Attribution attribution 400 - Adds IDFA to track data. iOS Optional Requires additional entitlements from Apple. Manual import option only. AppData appdata 500 - Adds app_uuid to track data. iOS, macOS, tvOS, watchOS Recommended - Datasource datasource 550 - Adds an additional config init option for datasource ids. iOS, macOS, tvOS, watchOS Recommended - DeviceData devicedata 525 - Add as additional device info to all track data. iOS Recommended - PersistentData persistentdata 600 - Adds ability to add persistent data to all track data. iOS, macOS, tvOS, watchOS Recommended - Volatile Data volatiledata 700 - Adds ability to add session persistent data to all track data - clears upon app termination/close. iOS, macOS, tvOS, watchOS Recommended Will supersede any Persistent value with the same key(s) Delegate delegate 900 - Adds multicast delegates to monitor or suppress track dispatches. iOS, macOS, tvOS, watchOS Optional - Connectivity connectivity 950 - Adds ability to flag track messages for delayed delivery due to connectivity loss. iOS, macOS, tvOS Recommended Requires SystemConfiguration DispatchQueue dispatchqueue 1000 - Adds persistent storage for queued dispatches iOS, macOS, tvOS, watchOS Recommended - Collect collect 1000 Dispatchers Packages and delivers track call to Tealium Collect or other custom URL endpoint. iOS, macOS, tvOS, watchOS Optional* - TagManagement tagmanagement 1100 Dispatchers UIWebview based dispatch service that permits library to run TIQ/utag.js. iOS Optional* Requires UIWebView RemoteCommands remotecommands 1200 - Permits configurable remote code block execution via URLScheme, UIWebView, or TagManagement. iOS Optional* - * Please read documentation for full details. Where a module is listed as optional, and it has a "module group" listed, one or both modules of the same module group is required to fulfil the library's tracking requirements. For example, Collect and Tag Management are in the "Dispatchers" group, and you need at least one of these enabled for any data to be sent. Likewise with the Persistent Storage group; you need one or the other to be enabled, or you will not get any persistent storage options. Recommended Default Modules Please speak to your account manager if you are unsure which products you are licensed for These are recommended default modules for most implementations. You are free to add/remove modules as needed. Option 1: If using Tealium iQ (Tag Management) only Core Attribution AppData Connectivity Consent Manager DataSource Delegate DeviceData DispatchQueue FileStorage Lifecycle Logger PersistentData RemoteCommands TagManagement VolatileData Option 2: If using Tealium UDH (Collect) only Core Attribution AppData Collect Connectivity Consent Manager DataSource Delegate DeviceData DispatchQueue FileStorage Lifecycle Logger PersistentData VolatileData Option 3: If using Tealium UDH and Tealium iQ together Please see Collect documentation to decide whether Collect module is actually required. Core Attribution AppData Collect Connectivity Consent Manager DataSource Delegate DeviceData DispatchQueue FileStorage Lifecycle Logger PersistentData RemoteCommands TagManagement VolatileData ... View more

Tag Management/Tealium iQ Enables remote configuration of JavaScript-based tags using Tealium iQ. All libraries supporting this feature implement a non-rendered web view to act as a host for the JavaScript tags. Data from tags is sent directly from the device to the tag vendor's server (e.g. Adobe, Criteo, Google). In order to use this feature, it must have been explicitly enabled in the remote publish settings (see https://community.tealiumiq.com/t5/Mobile-Libraries/Mobile-Publish-Settings/ta-p/13633), or in the case of the Swift library, it must be enabled in the native code when Tealium is initialized. If the Tag Management feature is disabled, the non-rendered web view will not be created, although the Android and iOS (Objective-C) libraries will still make a request for the "mobile.html" file, solely for the purposes of downloading the Mobile Publish Settings. This request comes from native code, and does not involve the web view. Tealium Collect/UDH Enables support for Tealium's Universal Data Hub (UDH) suite of products. When enabled, an HTTPS request will be sent directly to Tealium's servers for processing for each tracking call implemented in your app. This single HTTPS request can be used to power one or more of the following products simultaneously: AudienceStream EventStore AudienceDB & EventDB EventStream If you are not licensed for one of these products, you should disable the Tealium Collect service in your app, which can be done through the remote publish settings. For Swift, you will need to make sure the module is disabled, as it does not currently utilize the remote publish settings feature. This feature may be used in conjunction with the Tag Management feature, but please ensure that you do not also have the Collect Tag set up through Tealium iQ, as this will lead to double-counting (1 hit from the native Collect service, and one from the Tealium iQ Collect tag). Collect Tag vs. Native Collect Module If you are already using Tealium iQ in your app, then using the Collect tag offers some advantages over the native Collect module. The main benefit is that you have the ability to manipulate data using Extensions in Tealium iQ before the data is transmitted to the UDH. You can also use load rules to filter which events are sent to the UDH. If you are using the native Collect module, all events are sent to the UDH, and there are no options to manipulate the data, apart from by using enrichments in the UDH. If, however, you do not need to use Tealium iQ for tag delivery (e.g. you are using EventStream to deliver your data to third party tag vendors), then the Collect module offers some advantages; exclusively using the Collect module and disabling Tag Management will result in fewer HTTP(s) requests being made from the app, since instead of sending data to multiple vendors directly from the device, only a single request is sent to Tealium per tracking call implemented in the app. This may help to reduce battery and data consumption, resulting in a better experience for your end-users. Additionally, if you are using AudienceStream, the native module offers built-in Data Layer Enrichment (DLE) callbacks which can be used to personalize your app based on known visitor attributes (e.g. high value customers could receive additional features or promotions, based on the cross-device data Tealium holds in AudienceStream). If you implement the Collect tag through Tealium iQ, DLE will still function as expected, but visitor attributes will only be available at the JavaScript-level inside the non-rendered web view. Remote Commands Remote Commands (also known as Custom Remote Commands/Dynamic Triggers) provide the ability to trigger native code blocks from within the Tealium iQ non-rendered web view. For this reason, they can only be used if you have implemented/enabled the Tag Management feature/module in your app. Only remote commands that have been explicitly enabled will be able to run (there is no way for Tealium iQ to execute arbitrary code on the device). This feature is primarily used for cases where data held inside the non-rendered web view needs to be passed back to the native code for further processing (e.g. you may need to access a value stored in a cookie or localStorage inside the Tealium iQ web view). Another use for this feature would be to personalise parts of your app, for example, you may wish to trigger a survey in the app once the user has been through a particular journey, such as making a purchase. The flow for this particular example would be: Create some generic native code capable of triggering a local notification on the device, which prompts the user to take a survey. Register this block of code as a Remote Command with the Tealium API (See Links). In Tealium iQ, create a new "Custom Remote Command" tag, and make sure the command ID matches the command ID you used to register the command in the native code. Mappings can be set up to pass specific data variables back to the app, for example, you might wish to pass a customized survey message back to the app, e.g. "Thank you for making a purchase. Would you mind taking a short survey?". You might also pass back a specific URL to open when the user clicks the notification, so that you can pass the user through to a specific web-hosted survey using your survey tool of choice. In the app, the native code should look for specific variables passed back in the response (e.g. "survey_url" and "survey_title"), display the message in the notification, and launch a web view or the native browser when the user clicks the notification. If you wish to change the survey URL, or the message displayed to the user, you can now control this through Tealium iQ extensions, without needing to re-deploy your app. You can also disable the survey at-will, or change the trigger that leads to the survey being displayed (e.g. display on the home screen instead of the order confirmation screen). There are many other potential uses for Remote Commands, including remote configuration of third party SDKs in your app. Speak to your account manager/deployment engineer if you have any questions. Lifecycle Tracking Each platform has its own Lifecycle module, which enables automatic tracking of app lifeycle events (launch, wake, sleep) and associated data. Mobile Publish Settings (MPS) Mobile Publish Settings allow you to remotely control some aspects of the Tealium SDKs' functionality, without needing to deploy an app update. You can read full details in this article: https://community.tealiumiq.com/t5/Mobile-Libraries/Mobile-Publish-Settings/ta-p/13633 Storage In addition to passing specific data layer variables with each tracking call, some variables need to remain consistent throughout your app's lifecycle. Instead of manually sending these variables with every request, you can use one of our storage APIs to automatically add the data to each request. Volatile Storage Items added to volatile storage are kept until the app is cleared from memory (i.e. force-closed/restarted). From the point you set a volatile data variable, it will be sent on every subsequent request automatically until it is cleared. Volatile data is not stored on disk, so will not contribute to the app's disk usage footprint on the device. Persistent Storage Items added to persistent storage are kept for the lifetime of the app (until the user uninstalls the app or manually clears the app's data), or until you clear the variable via the API. Like volatile variables, persistent variables are sent with every tracking call until they are cleared. An example of a variable you might like to keep in persistent storage is a visitor id, such as a user's email address. Links RemoteCommands on tealium-ios RemoteCommands on tealium-swift RemoteCommands on tealium-android General Documentation - Swift General Documentation - Objective-C General Documentation - Android ... View more

Purpose Enables logging of debug information to the LLDB console. Supported Platforms iOS tvOS watchOS macOS Installation CocoaPods Framework will be auto-instantiated, so long as the pod is installed. Depends on TealiumCore pod. No additional import statements necessary besides import TealiumSwift . pod 'tealium-swift/TealiumLogger Carthage Framework will be auto-instantiated, so long as it is compiled into your app (included in "Embedded Binaries"). Depends on TealiumCore . No additional import statements necessary. TealiumLogger.framework Recommended Usage Usage of this module is recommended. If you do not enable it, you will not see any logging from the Tealium library. Included Variables No new variables are introduced by this module. Public API There are no public API methods for this module. The module can be controlled by using the settings available in the TealiumConfig object. Available Log Levels Log Level Description Enum value None Logging disabled TealiumLogLevelValue.none Errors Only errors will be reported TealiumLogLevelValue.errors Warnings Only errors and warnings will be reported TealiumLogLevelValue.warnings Verbose All log output will be reported, including an entry for each tracking call/dispatch TealiumLogLevelValue.verbose Future Improvements Additional logging to be added for all modules. Change Log Build 1.4.0 Improved logging for Persistent Data ... View more

Purpose Adds the UDH-generated data source variable to each dispatch. Supported Platforms iOS tvOS watchOS macOS Installation CocoaPods Framework will be auto-instantiated, so long as the pod is installed. Depends on TealiumCore pod. No additional import statements necessary besides import TealiumSwift . pod 'tealium-swift/TealiumDataSource Carthage Framework will be auto-instantiated, so long as it is compiled into your app (included in "Embedded Binaries"). Depends on TealiumCore . TealiumDataSource.framework import TealiumDataSource // allows datasource param to be set on the TealiumConfig class instance Recommended Usage Usage of this module is recommended if you are using the UDH. You can generate a data source key via the UDH user interface. If you are using Tag Management only, it currently doesn't have any effect, apart from adding a new variable to each dispatch. See the Data Sources documentation for more information on this feature. Included Variables The following variables will be transmitted with each tracking call while the module is enabled: Variable Name Description Example Value tealium_datasource Specifies the data source name. Added to every dispatch. abc123 Public API No public API methods available. The Data Source variable can be set via the TealiumConfig object (see Swift Class: TealiumConfig) Future Improvements No planned changes Change Log Build 1 Initial release ... View more

Basic Concepts This document covers all the basics to get you up and running with Tealium as quickly as possible. In most cases, the API calls described here are all you will ever need to implement, unless you want to use some of the more advanced features of the library, which are covered in separate documents (see Modules Documentation). Tracking Calls The Tealium tracking API provided by the Swift library is designed to capture two types of events: Screen Views In general, we advise that every screen in your app is tracked (usually in viewDidAppear or similar), and any other relevant variables should be passed in a Dictionary in the data parameter. User Interation Events (e.g. Button Clicks) You should add track calls for significant events in your app, e.g. a call-to-action button, "Buy Now", "Add To Cart". Adding more tracking calls upfront, before the app is deployed to the App Store, will reduce the need to add more tracking at a future date, and reduce the need for app updates. If in doubt, track it; tracking calls can be filtered out/ignored if not needed later on, but they are more tricky to add to your app later. Helper Class We recommend the use of a helper class to abstract the Tealium API implementation from the rest of your app. This will give you a single entry point from which to call Tealium, and in the event that we make breaking changes in future releases (we always try not to!), you only need to update the code in your helper file, and not in every single ViewController or Swift file. A sample helper class is provided in the GitHub repo. Sample Code Initialization/Instantiation This code should generally be run as part of your helper class to initialize Tealium for the first time. // REQUIRED Config object for lib let config = TealiumConfig(account: "tealiummobile", profile: "demo", environment: "dev", datasource: "test12", optionalData: nil) // OPTIONALLY set log level config.setLogLevel(logLevel: .verbose) // REQUIRED Initialization - recommend making tealium reference a member of your singleton helper; it should only be instantiated once let tealium = Tealium(config: config) { // Optional processing post init. } Modules The Tealium Swift library is modular. This means you only need to install the specific components you need, and any you don't need are excluded from your build. This saves resources while your app is running, and makes sure your end users get the best possible experience. See https://community.tealiumiq.com/t5/Tealium-for-Swift/x/ta-p/20533 for recommended module lists. Track Screen Views This code block will track a screen view on the homescreen, passing a Dictionary containing two key-value pairs, the first representing the customer id, and the second, an array of product IDs purchased in this transaction (in this instance, containing 1 product only). You may optionally specify a completion block, but you may pass nil if you don't need special completion handling. // assuming 'tealium' has already been instantiated tealium?.trackView(title: "Buy Now", data: ["customer_id" : "1234567890-a", "product_ids" : ["widget123"]], completion: nil) Track User Events This code block will track a button click on "Buy Now", passing a Dictionary containing a single key-value pair, representing the customer id. You may optionally specify a completion block, but you may pass nil if you don't need special completion handling. // assuming 'tealium' has already been instantiated tealium?.track(title: "Homescreen", data: ["customer_id" : "1234567890-a"], completion: nil) Add Persistent Data Persistent data storage should be used for those variables which rarely change during the app's lifecycle, but are required to be sent on every tracking call. An example of this may be a customer ID that stays the same until the user logs out. Persistent data remains set across multiple app launches (since it is stored on disk), and can only be modified by deleting the data through the persistent data API, or overwriting an existing key with a new value. Persistent data is merged with any dictionary passed in each tracking call ( trackView or track ), and sent to any enabled dispatch services. NOTE: Persistent Data storage is backed by either UserDefaults or File Storage, depending on the modules currently enabled. tealium?.persistentData()?.add(data: ["customer_id":"1234567890-a"]) Add Volatile Data Volatile data storage should be used for those variables that do not change during a single launch of the app, but may change for future launches. An example of this may be some sort of session ID, which is regenerated each time the user relaunches the app. Volatile data works in a similar way to persistent data, except that it is only kept in main memory, and never written to disk. Thus, force closing an app will clear all volatile data previously set. From the point it is set, volatile data will be sent on each subsequent tracking call, and its data merged with any Dictionary passed in to the tracking call. tealium?.volatileData()?.add(data: ["session_id":"1234567890232"])   ... View more