Tealium Learning Center

FUNCTION NAME DESCRIPTION init(account:String, profile:String, environment:String)  Constructor for a TealiumConfig object. getLogLevel() -> LogLevel Get the current log level for the library's logging mechanism.  setLogLevel(logLevel:LogLevel) Set the current log level for console output.  getOptionalData(key:String)->AnyObject? Get any optional data to accompany configuration. Intended for future extensions.  setOptionalData(key:String, value:AnyObject) Set optional data to accompany configuration. Intended for future extensions.   INIT init(account:String, profile:String, environment:String) Parameters Description Example Value account Tealium account name tealiummobile profile Tealium profile demo  environment  Tealium environment identifer dev // SAMPLE // Standard Init var config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev_qa_or_prod") // Adding log level setting config.setLogLevel(logLevel: .Warnings)   GET LOG LEVEL getLogLevel() -> LogLevel // SAMPLE let level = config.getLogLevel() // Log Level Options switch(level){ case .None: // Print nothing case .Errors: // Print only errors case .Warnings: // Print errors and warnings case .Verbose: // Print debug messages, errors, and warnings // This is the default option }   SET LOG LEVEL setLogLevel(logLevel:LogLevel) Parameters Description Example Value logLevel Log level enum to set library debugger to. Options are: .None .Errors (errors only) .Warnings (errors and warnings only) .Verbose (all debug messages) .Errors // SAMPLE config.setLogLevel(logLevel:.Warnings)   GET OPTIONAL DATA  Intended for future extensions. getOptionalData(key:String) Parameters Description Example Value key Required String of key to retrieve data for. "someKey" // SAMPLE if let value = config.getOptionalData(key: tealiumKey_overrideCollectURL) as? String { print("Override url for the collect dispatch service has been set to: \(value)") }   SET OPTIONAL DATA  Intended for future extensions. Currently can be used to set an override to the destination URL for dispatches (tealiumKey_overrideCollectURL key). setOptionalData(key:String, value:String) Parameters Description Example Value key Required String "someKey" value Required String "someValue"  // SAMPLE config.setOptionalData(key: tealiumKey_overrideCollectURL, value:"https://aleternate.destionation.url")   ... View more

This guide shows how to add, configure, and track events for a C# application using the Tealium C# Integration library. In this article: Table of Contents Placeholder Installation Requirements Tealium account enabled for AudienceStream, DataAccess, or EventStream. Xamarin Community Edition+ Get the Code The code for the Tealium C# library is stored in GitHub. You must retrieve the code to get started. Download: Tealium for C# Code Setup Import the Tealium folder into your solution. using TealiumCSharp; Initialization Once the Tealium for C# package is installed you are ready to start coding. Use the following code to initialize with the following parameters: account - the name of your account. profile - the name of your profile within your account. environment - "qa" or "prod" visitorID - a 32 character alphanumeric string identifier that should be unique to a user, app instance. modules - (optional) modules to be initialized with library. Default modules if none provided: AppDataModule, CollectModule, LoggerModule. dataSourceKey - (optional) the data source key from UDH. overrideCollectUrl - (optional) custom endpoint for the Tealium Collect service. optionalData - (optional) dictionary for module use. Null acceptable. // SAMPLE Config tealConfig = new Config("account", "profile", "environment", "visitorID", new string[] { <modules> }, "dataSourceKey", "overrideCollectUrl", new Dictionary<string, object> optionalData); Tealium tealium = new Tealium(tealConfig); Tracking Once the Tealium object has been defined you can begin tracking events with the method Track() , which takes the following parameters:: eventName - a name to identify the event customData - (optional) custom data dictionary to send with track call completion - (optional) completion block to trigger after track call // SAMPLE // Full argument track call - illustrating call for a UI event with a callback. tealium.Track("eventName", customData, (success, info, error)=>) { Debug.WriteLine("eventTrackComplete: was successful: " + success); }); Below are two convenience methods for calling Track() without the optional parameters: // Convenience track call with only a string identifier for an activity type call. tealium.Track("My Event"); //Convenience track call with event title and optional data dictionary Dictionary<sting, object> customData = new Dictionary() { {"foo1", new string[]{"a","12"}}, {"foo2", "bar2"}, {"foo3", "bar3"} }; tealium.Track("My Event", customData); Validation Use Live Events or Trace to validate that Tealium is receiving your tracking calls. Xamarin Mobile Applications If you are building a mobile application in Xamarin, you will use bindings to our iOS and Android libraries. Tealium for iOS Xamarin - Binding an iOS Objective-C Library Tealium for Android Xamarin - Binding a Java Library Function Definitions Config() public Config (string account, string profile, string dev, string visitorId, string[] modules, string datasource = null, string overrideCollectUrl = null, Dictionary<string, object> optionalData = null) Parameters Description Example Value account Tealium Account tealium profile Tealium profile mobile_division environment Tealium environment. Currently optional prod visitorID 32-char alphanumeric string identifier that should be unique to a user, app instance, or device 612040730c8c11e6b4cbacbc329f41b7 modules Modules to be initialed with library See Available Modules dataSourceKey Data Source key from UDH abc123 overrideCollectUrl Custom endpoint for Tealium Collect service - optionalData Dictionary<string, object> for module use. Null acceptable. Value not typically needed for most setups - //Sample Config tealConfig = new Config("account", "profile", "environment", "visitorID", new string[] { <modules> }, "dataSourceKey", "overrideCollectUrl", new Dictionary<string, object> optionalData); The config object has a modules string[] property that must be populated with the string representations of each module desired to use with library. See the Available Modules section Tealium() Tealium(Config config) Primary object constructor Parameters Description Example Value config Required Config instance - //Sample Config tealConfig = new Config("account", "profile", "environment", "visitorId", new string[] { <ModuleNames> }, "datasouceId", "overrideCollectUrl", new Dictionary<string, object> optionalData); Tealium tealium = new Tealium(tealConfig); Enable() Automatically called with the initial initialization. Re-enable the Tealium instance and any internal modules if the library had been disabled prior. //Sample tealium.Enable() Disable() Disable library modules from temporarily processing events. May deinit internal class objects. //Sample tealium.Disable() Track() Track(string eventName, Dictionary<string, object> customData, TrackCompletion completion) Parameters Description Example Value eventName Required string identifier for the tracked event "aButtonWasTapped" customData Optional Dictionary<string, object> of key-value data to include with track call - completion Optional completion block to be triggered once call has been completed - //Sample Dictionary<string, object> data = new Dictionary() { {"foo1", new string[]{"a","12"}}, {"foo2", "bar2"}, {"foo3", "bar3"} }; tealium.Track("My Event", customData, (success, info, error) => { Debug.WriteLine("Track action completion block triggered."); Debug.WriteLine("Success: " + success + " info: " + info + " error: " + error); }); TrackCompletion The optional callback for track calls will contain the following parameters: Parameters Description Example Value successful Bool status if the track call could be delivered true Dictionary<string, object> info Dictionary<string, object> containing track and response data - error Optional error from any dispatch services encountering a delivery or response issue - Available Modules The following string values can be used to enable modules with the current build. Module Name Description AppDataModule Adds automatic data points to calls CollectModule Delivers processed events to Tealium Collect endpoint LoggerModule Provides debug output //Sample config.Modules = new string[] { AppDataModule.Name, CollectModule.Name, LoggerModule.Name }; Use the .Name constant of each Module class. Change Log 1.0.0 Initial ... View more

This article describes the feature sets available across all of the Tealium installation libraries. Many features introduce new event attributes to the data layer. In this article: Table of Contents Placeholder Device Languages - Summary    Android iOS Objective-C tvOS Objective-C Swift Roku App Data  ✔  ✔  ✔   ✔   Lifecycle Events (auto-track)  ✔  ✔  ✔  ✔   UI Events (auto-track)        ✔   Carrier Data  ✔  ✔  ✔  ✔    Consent Management     ✔   ✔ ✔   Collect Dispatch Service  ✔  ✔  ✔  ✔  ✔ Custom Persistence  ✔  ✔  ✔  ✔  ✔ Device Data  ✔  ✔  ✔   ✔   Remote Configuration  ✔  ✔  ✔     Tag Management Service  ✔  ✔  ✔  ✔    Tealium Data  ✔  ✔  ✔  ✔  ✔ Offline Queuing  ✔  ✔  ✔  ✔    Languages - Summary    Java Python C# Win UWP App Data         Lifecycle Events (auto-track)         UI Events (auto-track)         Carrier Data         Collect Dispatch Service  ✔  ✔  ✔  ✔ Custom Persistence  ✔       Device Data         Remote Configuration         Tag Management Service         Tealium Data  ✔  ✔  ✔   Offline Queuing          App Data Information regarding the host application adds the following to the data layer: Event Attribute Description Example Type app_name Application name "Digital Velocity" string app_rdns Reverse DNS Bundle id/package name "com.digitalvelocity.alpha" string app_version Application version "1.2.0" string Lifecycle Events (auto-track) Provides automatic tracking for the following application lifecycle events: launch, wake, and sleep. Event Attribute Description Example Type lifecycle_dayofweek_local Local day of week (1=Sunday, 2=Monday, etc) 3 number* lifecycle_dayssincelaunch Days since first launch in whole number increments 0 (24 hours have not yet elapsed) number* lifecycle_dayssinceupdate Days since the app was updated in whole number increments "1" string lifecycle_diddetectcrash 'true' if a crash was determined at time of launch. Otherwise not populated.  "true" string lifecycle_firstlaunchdate GMT timestamp of very first detected launch. ISO-8601format for Zulu time. "2016-05-16T16:32:04Z" string lifecycle_firstlaunchdate_MMDDYYYY GMT timestamp of very first detected launch. MM/DD/YYYY format. "5/16/2016" string lifecycle_hourofday_local Local hour of day (24 hour format) 13 number* lifecycle_isfirstlaunch 'true' if launch is very first. Otherwise not populated. "true" string lifecycle_isfirstlaunchupdate 'true' if launch is very first after a detected app version update. Otherwise not populated. "true" string lifecycle_isfirstwakemonth 'true' if launch event is the first for the current month. Otherwise not populated. "true" string lifecycle_isfirstwaketoday  'true' if launch/wake event is the first for current day. Otherwise not populated. "true" string lifecycle_lastlaunchdate  GMT timestamp of prior recorded launch. ISO-8601 format for Zulu time. Not populated if it is within the first session. "2013-07-11T17:55:04Z" string lifecycle_lastsleepdate  GMT timestamp of prior recorded sleep event. ISO-8601 format for Zulu time. "2013-07-11T17:55:04Z" string lifecycle_lastwakedate  GMT timestamp of prior recorded wake event. ISO-8601 format for Zulu time. "2013-07-11T17:55:04Z" string lifecycle_launchcount  Total whole number of launches for application since most recent version update (restarts when a new version detected). 3 number* lifecycle_priorsecondsawake Populated only during launch events. Whole seconds application was awake between wakes and sleeps. Aggregate of all these wakes & sleeps until a launch event. 148 number* lifecycle_secondsawake  Populated only during sleep events. Whole seconds application has been awake from most recent wake to the sleep event. 480 number* lifecycle_sleepcount  Total number of times app was detected to have gone to sleep / background. 3 number* lifecycle_totallaunchcount Total number of launches since app was installed. Only resets if application deleted and reinstalled.  5 number* lifecycle_totalsecondsawake  Total number of seconds application has been awake. Only resets if application deleted and reinstalled. 800 number* lifecycle_totalsleepcount  Total number of times application was detected to have gone to sleep. Only resets if application deleted and reinstalled. 8 number* lifecycle_totalcrashcount Total number of times an application failed to properly log a sleep event, resulting in a lifecycle sequence discrepancy caused by a crash. Only resets if applicaiton deleted and reinstalled. 2 number* lifecycle_totalwakecount  Total number of launches and wakes. Only resets if application deleted and reinstalled. 7 number* lifecycle_type  Lifecycle event type (launch, wake, or sleep) "wake" string lifecycle_updatelaunchdate GMT timestamp of first launch/wake after a app version update detected. ISO8601 format for Zulu time. "2016-05-16T16:32:04Z" string lifecycle_wakecount Total number of launches and wakes for this application version. Resets if a new host application version detected. 34 number* UI Events (auto-track) Provides automatic tracking for view changes and basic UI interactions, such as button taps.  All auto-tracked events set this attribute: autotracked="true" Carrier Data Provides information regarding the mobile carrier.  Event Attribute Description Example  Type carrier Name of the Carrier "AT&T" string carrier_iso Carrier ISO 3166-1 country code "us" string carrier_mcc Mobile ITU-T E.212 country code "310" string carrier_mnc Mobile Network Code "410" string  Consent Management Provides information about consent tracking preferences.  Event Attribute Description Example  Type policy The policy under which consent was collected "gdpr" string consent_status The user's current consent status "consented" string consent_categories An array of the user's selected consent categories  ["analytics", "cdp"]  array of strings Device Data Provides information regarding the host device. Event Attribute Description Example  Type device Name of the device "iPhone 6s" string device_architecture Bit architecture of device (32, 64, etc.) 64 number* device_advertising_id Optional Advertising identifier. Not automatically available for all devices. "03402320-245A-4ED4-BEAE-A1F50E21C55E" string device_battery_percent Whole number perscent representation of device's remaining battery power. 100 number* device_cputype Central Processor Unit type (arm6, arm7, etc.) "ARM64" string device_ischarging  Is the device actively charging (true/false) "false" string device_language  Two-letter IOS-639-1 language identifier (en, ja, etc.) "en" string device_orientation Orientation of device at time of event. (portrait, landscape, etc.)  "Portrait" string device_resolution   Resolution of a device. "750x1334" string Dispatch Service - Collect Delivery of event dispatches to Tealium's Collect service using the platform's native URL communications service. Event Attribute Value dispatch_service "collect" Dispatch Service - Tag Management Direct delivery of event dispatches to vendor endpoints, configured using Tealium's TIQ Tag Management service. This service typically uses an unrendered WebView to load and execute tag management capabilities similar to those found in Tealium web-based solutions. Event Attribute Value dispatch_service "tagmanagement" Offline Queuing Preserves event dispatch data for later delivery when, for example, a device has momentarily lost network connectivity. Populates the following Event Attribute within the dispatch data that was queued:  Event Attribute Value was_queued "true" Persistence Ability to save custom dispatch data between application shutdowns. This data is included in all event dispatches. See platform library guides for specific usage. No event atttributes are directly associated with this feature. Remote Configuration Provides the ability for the installation to receive remote configuration updates from Tealium's Mobile Publish Settings.  Tealium Data Default event attributes that are present for all modern Tealium libraries. Event Attribute Description Example  Type tealium_event Title of the event. Value populated by the 'title' argument of the Tealium provided track calls. Does NOT need to be unique. "button_tapped" string tealium_random Random 16 digit number generated per event. Prepadded with zeroes to maintain 16 digit length. 1234567890123456 number* tealium_account Tealium account name used to initialize a Tealium integration library. "Tealium" string tealium_environment Tealium TIQ environment used to initialize a Tealium integation library. (usually 'dev', 'qa', or 'prod'). "prod" string tealium_library_name Name of the platform integration library. "swift" string tealium_library_version  Version of the platform integration library. "1.2.0" string tealium_profile Tealium profile name used to initialize a Tealium integration library. "demo" string tealium_datasource 6 digit alphanumric identifier provided by the Universal Data Hub (UDH) "abc123" string tealium_session_id Unix epoch timestamp in milliseconds, no decimals, of first event. Resets after a new session starts, typically a new launch). 1496350751928 number* tealium_visitor_id Unique app-device visitor id that differentiates users. Required by the Collect service. (32 character alpha-numeric) string tealium_timestamp_epoch  Unix timestamp at UTC. 1496350751 number  All values are converted to strings for delivery.  Variables/event attributes listed as 'number' types are originally number values and could be coerced back into numbers from these stringified values. ... View more

Purpose Enables triggering of native code blocks from events in Tealium iQ, controlled by extensions and load rules. Mapped data may also be passed back in remote command calls, enabling limited control of app behavior through Tealium iQ. A simple example would be setting the background color of a screen, based on a hex color code passed back from Tealium iQ. See General Mobile Concepts for further explanation. 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/TealiumRemoteCommands Carthage Framework will be auto-instantiated, so long as it is compiled into your app (included in "Embedded Binaries"). Depends on TealiumCore . TealiumRemoteCommands.framework import TealiumRemoteCommands // required if you need to interact with the Remote Commands API External Dependencies TealiumTagManagement module. Not strictly a complile-time dependency, but Remote Commands can only currently be triggered from the Tag Management module. Recommended Usage Usage of this module is optional. It is automatically included in Carthage and CocoaPods framework builds. Included Variables No additional variables are introduced by this module. Public API init (Remote Command object) Creates a new remote command object ready to be passed to the add command. Parameter Description Example Value commandId Required String identifier for the remote command logger description Optional String description of the remote command Log Response object to console queue Queue on which to trigger the code block DispatchQueue.main completion The block of code to trigger - // SAMPLE let customCommand = TealiumRemoteCommand(commandId: "logger", description: "Log Response object to console", queue: DispatchQueue.main) { (response) in // code to execute print("Custom command response: \(response)") }) add Registers a specified remote command with Tealium for later triggering. Tealium must have been initialized before adding a new Remote Command. add(remoteCommand: TealiumRemoteCommand) //Sample var tealium: Tealium? let customCommand = TealiumRemoteCommand(commandId: "logger", description: nil, queue: DispatchQueue.main) { (response) in // code to execute print("Custom command response: \(response)") }) if let remoteCommands = self.tealium?.remoteCommands() { remoteCommands.add(customCommand) } else { print("Remote commands not available") } remove Removes a previously-registered remote command to prevent it being triggered again. remove(commandWithId: String) // assumes "tealium" previously instantiated tealium?.remoteCommands()?.remove(commandWithId: "logger") disableRemoteCommands Disables the remote commands module. disableRemoteCommands() // assumes "tealium" previously instantiated tealium?.remoteCommands()?.disableRemoteCommands() enableRemoteCommands Enables the remote commands module (only required if previously disabled; default is enabled). enabledRemoteCommands() // assumes "tealium" previously instantiated tealium?.remoteCommands()?.enableRemoteCommands() disableRemoteHTTPCommand Disables the built-in remote HTTP command, but leaves the remote commands module enabled for other commands. disableRemoteHTTPCommand() // assumes "tealium" previously instantiated tealium?.remoteCommands()?.disableRemoteHTTPCommand() enableRemoteHTTPCommand Enables the built-in remote HTTP command (only required if previously disabled; default is enabled). enableRemoteHTTPCommand() // assumes "tealium" previously instantiated tealium?.remoteCommands()?.enableRemoteHTTPCommand() Special Commands Remote HTTP Command This is a reserved internal command with identifier _http which triggers an HTTP request from native code, and passes the response back to the Tealium iQ web view. This can be used in some cases to bypass CORS restrictions that may be encountered in a web browser. To use this command, there are specific mapping names you must use: url (mandatory) - The URL of the request you wish to trigger method (mandatory) - The HTTP method you wish to call. PUT, GET and POST are currently the only supported methods headers (optional) - A JavaScript object (JSON) containing the header key/value pairs to pass along with the request (e.g. {"Content-Type": "application/json"}) callback_function (optional) - A JavaScript function to be invoked when the command has completed. The callback function will be passed 2 parameters: code is the HTTP response code (404, 200 etc.), and body , which is the response body from the request. Here's a sample callback function: var my_callback = function(code, body) { // assuming the response body was a JSON object, this will log a variable called my_response_variable to the console in the web view console.log(body.my_response_variable); } For a working example, see this article: https://community.tealiumiq.com/t5/Mobile-Libraries/Mobile-App-Download-Tracking-with-Adobe-Analytics/ta-p/17914 Future Improvements No planned changes Change Log 1.6.5 Fixed a bug causing the Remote HTTP command to occasionally not be called when invoked 1.4.0 Fixed bad configuration in sample app Removed deprecated enable/disable methods ... View more

Purpose Enables Tealium iQ Tag Management. This module works in conjunction with your Tealium iQ account to run JavaScript-based tags in your Swift app. It implements a non-rendered UIWebView instance to act as a host for running JavaScript tags. 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/TealiumTagManagement 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. TealiumTagManagement.framework External Dependencies UIKit (UIWebView) Recommended Usage Usage of this module is mandatory if you need to make use of Tealium iQ's Tag Management capabilities, otherwise it is optional. It is automatically included in Carthage and CocoaPods framework builds. 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 tagmanagement Public API All the normal UIWebview protocols are accessible by adding another object conforming the UIWebView delegate to the module's multicast delegate: tealium.tagManagement()?.delegates.add(MY_OBJECT) Future Improvements Migrate from UIWebView to newer WKWebView. Currently, this is blocked because support for custom URL schemes was only introduced in iOS 11. The Remote Commands module makes use of this feature, so for maximum compatibility, we have kept UIWebView, which has full support for custom schemes in all iOS versions. Once iOS 11 has wider adoption (currently at 52%), we will consider migrating to WKWebView. Change Log 1.6.5 Memory leak fixes Nested objects now supported 1.4.0 Minor updates for Swift 4.0 compatibility ... View more

Purpose A multicast delegate handler to allow delegates to monitor or suppress dispatch events. 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/TealiumDelegate Carthage Framework will be auto-instantiated, so long as it is compiled into your app (included in "Embedded Binaries"). Depends on TealiumCore . TealiumDelegate.framework import TealiumDelegate // required if you need to set up a tracking delegate Recommended Usage Usage of this module is optional. You only need to use it if you need fine control over individual dispatches/events (e.g. to block an event from being sent, or to monitor tracking calls for success/failure). Included Variables No additional variables are introduced by this module. Public API add Adds a weak pointer to a class instance conforming to the TealiumDelegate protocol. add(delegate: TealiumDelegate) Parameters Type Description delegate TealiumDelegate Any class conforming to the TealiumDelegate protocol. // SAMPLE func someSetupMethod { // Assuming 'tealium' was initialized earlier and "self" conforms to TealiumDelegate protocol tealium.delegates().add(delegate:self) } remove Removes the weak pointer reference to the given class conforming to the TealiumDelegate protocol. remove(delegate: TealiumDelegate) Parameters Type Description delegate TealiumDelegate Any class conforming to the TealiumDelegate protocol. // SAMPLE func someSetupMethod { // Assuming 'tealium' was initialized earlier and "self" conforms to TealiumDelegate protocol tealium.delegates().remove(delegate:self) } removeAll Removes all weak pointers from tracking. removeAll() // SAMPLE func someSetupMethod { // Assuming 'tealium' was initialized earlier tealium.delegates().removeAll() } TealiumDelegate Protocol tealiumShouldTrack() If method returns true, the tracking call will be allowed to complete. If method returns false, tracking call will be canceled. tealiumShouldTrack(data: [String:Any]) -> Bool Parameters Description Example Value data [String:Any] dictionary of data. ["somekey" : "somevalue"] // SAMPLE class SomeClass { func someSetupMethod { // Presuming 'tealium' initialized earlier tealium.delegates().add(delegate:self) } } extension SomeClass : TealiumDelegate { func tealiumShouldTrack(data:[String:Any]) -> Bool { // Can check keys and values for data that should trigger a false, otherwise.. return true } } tealiumTrackCompleted() Allows monitoring of completed track calls and handling of any errors tealiumTrackCompleted(success: Bool, info: [String:Any]?, error: Error?) Parameters Description Example Value success Boolean if dispatch completed acceptably. true info Dictionary of the original payload and any other returned data regarding dispatch. ["somekey" : "somevalue"] error Error, if any, encountered during dispatch processing. Error from a module, e.g. TealiumCollectError.xErrorDetected // SAMPLE class SomeClass { func someSetupMethod { // Presuming 'tealium' initialized earlier tealium.delegates().add(delegate:self) } } extension SomeClass : TealiumDelegate { func tealiumTrackCompleted(success: Bool, info: [String:Any]?, error: Error?) { // Can check if successful, response info, and if any errors occurred. } } Future Improvements No planned changes Change Log 1.6.5 Tealium completion handler moved to TealiumCore framework. Build 1 Initial release ... View more

Purpose Automatically tracks app lifecycle events and associated data. The launch event is triggered when the library is loaded for the first time, sleep event on UIApplicationWillResignActive notification and wake event on UIApplicationDidBecomeActive. 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/TealiumLifecycle Carthage Framework will be auto-instantiated, so long as it is compiled into your app (included in "Embedded Binaries"). Depends on TealiumCore . TealiumLifecycle.framework import TealiumLifecycle // only required if you need to manually call the Lifecycle API External Dependencies UIKit* If the UIKit dependency is added to the target app, no further configuration or implementation is necessary. For other platform builds (watchOS, macOS), the lifecycle functions can be triggered manually, see the Public API Methods section below. Recommended Usage Usage of this module is recommended if you are using Adobe Analytics. Otherwise, it is optional, but the additional events captured (launch/wake/sleep) may be useful to you for other vendor implementations. Included Variables The following variables will be transmitted with each tracking call while the module is enabled: Variable Name Description Data Type Example lifecycle_diddetect_crash Was a crash detected during this launch/wake event. Populated only if true. Boolean true 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_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 update) Number 3 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_secondsawake Whole seconds app was awake since most recent wake/launch. Number 30 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_updatelaunchdate GMT timestamp of first wake/launch after a version update has been detected String 2014-09-08T18:10:01Z lifecycle_type Type of lifecycle call String "launch", "wake", "sleep" lifecycle_wakecount Total number of launches + wakes in this version of your app (resets if updated) Number "29" Crash Detection The Lifecycle module performs basic crash detection, but does not collect any details about the cause of the crash. It records a crash whenever a lifecycle launch event is seen, without a preceding sleep event. Normally, when an app is closed by the user, a notification from the OS would trigger a lifecycle sleep event, but if the app crashes, there is no time for this to happen, and thus, no sleep event takes place. On the subsequent launch after the crash, the "lifecycle_diddetectcrash" variable is set to true, and the "lifecycle_totalcrashcount" variable is incremented by 1. If you require more advanced crash detection, our Crash Reporter module provides full details of each crash, and the reasons for the crash. This is currently supported on iOS only. Public API You only need to use these API methods if you are targeting a platform that doesn't support UIKit. launchDetected Updates lifecycle records with a launch event and trigger a lifecycle event dispatch. // launchDetected() // SAMPLE func someMethodCalledAtLaunchTime { // Presuming 'tealium' was initialized earlier tealium.lifecycle().launchDetected() } wakeDetected Updates lifecycle records with a wake event and trigger a lifecycle event dispatch. NOTE: wakeDetected() calls can be safely added after a launchDetected() in the same function. The module will only accept a single launch event per instantiated instance. // wakeDetected() // SAMPLE func someMethodCalledWhenAppStarts { // Presuming 'tealium' was initialized earlier tealium.lifecycle().wakeDetected() } sleepDetected Update lifecycle records with a sleep event and trigger a lifecycle event dispatch. // sleepDetected() // SAMPLE func someMethodCalledBeforeAppTerminated { // Presuming 'tealium' was initialized earlier tealium.lifecycle().sleepDetected() } Future Improvements No planned changes. Change Log 1.6.5 Fixed a bug that occasionally caused crash data to persist across more than 1 event, potentially causing inflated crash metrics in analytics reports. Crashes are now only sent on "launch" 1.4.0 Changed to use same NSNotifications as Objective-C library (UIApplicationDidBecomeActive and UIApplicationWillResignActive). This ensures lifecycle events are captured as quickly as possible. May potentially impact lifecycle reporting, but should be more accurate than before. Changed implementation of NSKeyedUnarchiver to support Swift 4.0, and add additional error checking ... View more

This guide shows how to add Tealium to your Java application to track event activity.  Before you begin, here's a video introduction to the platform: Table of Contents Placeholder Installation Requirements  Before proceeding, ensure you have satisfied the following requirements: Active Tealium AudienceStream account Java IDE eg. Eclipse Java 7 or higher Get the Code The code for the Tealium Java library is stored in Github. You must retrieve the code to get started. Download: Tealium for Java We recommend cloning the library (instead of downloading) to make it easier to update to future releases. Code Setup Import all of the .java files from the src/main/java/com/tealium directory, then add this code: import com.tealium.* Using Maven Make the following changes  your pom.xml file: Add the repository: <repository> <id>maven-tealium</id> <url>s3://maven.tealiumiq.com/java/releases/</url> </repository> Add the dependency: <groupId>com.tealium</groupId> <artifactId>java</artifactId> <version>1.0.1</version>   Initialization Once the Tealium files are added to your project you are ready to start coding. The Tealium instance must be invoked with the following parameters before you can begin tracking: account - the name of your account profile - the name of the profile within your account environment - one of "dev", "qa", or "prod" Tealium tealium = new Tealium.Builder("ACCOUNT", "PROFILE", "ENVIRONMENT").build(); Tracking Once the Tealium instance has been defined you can begin tracking events with the method track() , which takes the following parameters: eventName (required) - a name to identify the event eventData (optional) - an object with event attributes as key/value pairs callback (optional) - a function to be called when the track() method completes   // Set event attributes Map<String, Object> data = new HashMap<>(2); data.put("user_id", "0123456789"); data.put("email_address", "user@example.com"); // With optional callback DispatchCallBack callBack = new DispatchCallBack(){ public void dispatchComplete(boolean success, String encodedURLString, String error){ // Callback handling System.out.println(Dispatch successful: " + String.valueOf(success)); } } // Tracking a login event tealium.track("user_login", data, callBack); Watch this video for a quick summary of the installation steps:   Function Definitions Tealium.Builder() Instantiate a Tealium object. Tealium.Builder(account, profile, environment).build() Parameters Type Description Example Value account String Tealium account name "companyxyz" profile String Tealium profile "main"  environment  String Tealium environment identifer "prod" // Init Tealium Tealium teal = new Tealium.Builder('ACCOUNT', 'PROFILE', 'prod').build(); track() Track an event with associated data and, optionall, trigger a callback function. track(eventName, eventData, [callback]) Parameters Type Description eventName String Name of event (becomes the event_name event attribute value) eventData Map Object (Optional) Map<String, Object> of additional data source keys and values optional_callback Function (Optional) Object conforming to the Tealium call back interface // Event attributes Map<String, Object> data = new HashMap<>(2); data.put("user_id", "0123456789"); data.put("email_address", "user@example.com"); // With optional callback DispatchCallBack callBack = new DispatchCallBack(){ public void dispatchComplete(boolean success, String error) { // Callback code here } } tealium.track("user_login", data, callback); getDataManager() Fetch the DataManager object. The Data Manager processes call time data and handles persistent data. getDataManager() Returns Description Example Value DataManager Instance of the Tealium Data Manager object NA DataManager dm = tealium.getDataManager() addPersistentData() Use the DataManager to make data available across multiple app sessions. addPersistentData(map<String, Object>) Parameters Description Example Value data Required map to add to the existing persistent map <String,Object> ["key":"value"] Map<String, Object> data = new HashMap<>(); data.put("aKey", "aValue") tealium.getDataManager().addPersistentData(data);  deletePersistentData() Use the DataManager to delete previously persisted data by providing a list of keys to delete. deletePersistentData(array<String>) Parameters Description Example Value keys Array of Keys as strings ["key1", "key2"] List<String> list = new List<>(); list.append("key_to_delete"); tealium.getDataManager().deletePersistentData(list); getPersistentData() Use the DataManager to retrieve data that has been persisted. getPersistentData() Returns Description Example Value Map Of type <String,Object> ["key1", "key2"] Map<String,Object> persistentData = tealium.getDataManager().getPersistentData() getSessionId() Use the DataManager to fetch the current session ID. A session ID is created on initialization of the Tealium object. getSessionId() Returns Description Example Value String String representation of a timestamp in milliseconds "1473371215123" tealium.getDataManager().getSessionId()  resetSessionId() Use the DataManager to reset the session ID. For use when needing to start a new session other than at app start time. resetSessionId() Returns Description Example Value String New String representation of a timestamp in milliseconds that will be added to all dispatches for the remainder of the current session. The returned String is for monitoring convenience as it is automatically added to the volatile data store when this method is called. "1473371215123" tealium.getDataManager().resetSessionId()    ... View more

Purpose Automatically triggers tracking calls when certain user interface interactions take place, e.g. taps, swipes, screen views. Features Automatically trigger track calls from UIViewController view appearances Automatically trigger track calls for UI Events (ie button taps) Includes delegate methods for reporting or suppressing autotracked data Uses method swizzling on UIApplication and UIViewController classes. Disable/exclude if you would prefer to avoid swizzling in your app. Supported Platforms iOS tvOS 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/TealiumAutotracking Carthage Framework will be auto-instantiated, so long as it is compiled into your app (included in "Embedded Binaries"). Depends on TealiumCore .  TealiumAutotracking.framework import TealiumAutotracking // required if you need to interact with the autotracking API External Dependencies UIKit, UIApplication Bridging Header Please note, this module has been ported from Objective-C code, and as such, requires a Bridging Header. How to create a Bridging Header In your Swift project, create a new file. When prompted to select a file type, select Objective-C File. Give this file a temporary name, such as "placeholder.m", as you are going to remove it later. Click "Finish", and XCode should prompt you to create a Bridging Header (if it doesn't, you probably already have a Bridging Header in your project). Press "Create Bridging Header" to continue, and Xcode will automatically create the new header file for you. Delete your "placeholder.m" file from the project. You will notice a new file called -Bridging-Header.h Add the following import statements to the new Bridging Header: #import "UIApplication+TealiumTracker.h" #import "UIViewController+TealiumTracker.h" Recommended Usage In general, usage of this module is discouraged and not recommended for the following reasons: Increased memory usage Increased possibility for crashes to occur due to UI changes outside of Tealium's control (e.g. UI component being deallocated before the track call has completed) Increased battery consumption Unwanted additional tracking calls Does not fully remove the need to add additional tracking data/events, so additional coding is still required As an alternative to Autotracking, we strongly recommend you spend time carefully planning the tracking and data you need to capture, and have your developers pass this data to Tealium at the appropriate time. Autotracking may be useful if you are evaluating Tealium and need a quick implementation, but it is unlikely to fulfill all your tracking requirements on its own. Included Variables The following variables will be transmitted with each tracking call while the module is enabled: Variable Name Description Example Value autotracked Set to true and added to each autotracked tracking call true Public API The following methods are available to change the default behavior of the Autotracking module, or to monitor autotracked tracking calls: tealiumAutotrackingShouldTrack tealiumAutotrackingShouldTrack(data: [String:Any]) -> Bool Parameters Description Example Value data Dictionary with String keys and Any value type. Values are typically String or [String] ["key":"value"] // SAMPLE func tealiumAutotrackShouldTrack(data: [String:Any]) -> Bool { // Filter out View appearance events if data["tealium_event_type"] as? String == "view" { return false } return true } tealiumAutotrackDidComplete tealiumAutotrackDidComplete(success:Bool, info:[String:Any]?, error:Error?) Parameters Description Example Value success If the autotracked triggered call was successful. true info Optional information as a [String:Any] dictionary regarding the track call. Typically holds delivery type info, final call format, and the payload (the data dictionary used to generate the call).   error Error, if any, returned.   // SAMPLE func tealiumAutotrackDidComplete(success:Bool, info:[String:Any]?, error:Error?) { print("Tealium autotrack call completed with info: \(info)") } Future Improvements Migrate fully to Swift Extend API and improve stability to mitigate possible sources of crashes Change Log 1.6.5 No functional changes. Minor code change to import TealiumCore module for Carthage builds. Build 1 UI Event Autotracking UIViewController viewDidAppear Autotracking Completion & suppression delegate methods ... View more

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

FUNCTION NAME DESCRIPTION init?(config:TealiumConfig) Library initializer. getDataManager() Access the Data Manager for additional options.  track(title:String, data:[String:AnyObject], completion:((success:Bool, encodedURLString: String, error:NSError?)->)?)  Primary Track call for events. track(encodedURLString:String, completion:((success:Bool, encodedURLString: String, error:NSError?)->)? Alternate Track call using prepackaged encoded URL Strings.   INIT init?(config: TealiumConfig) Parameters Description Example Value config Required TealiumConfig object (see TealiumConfig) // SAMPLE // Simple Init let config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "your_environment") guard let tealium = Tealium(config: config) else { // Library failed to initialize return }   DATA MANAGER The Data Manager instance processes call time data and handles persistent data. getDataManager() // SAMPLE tealium.getDataManager()   TRACK  tealium.track(title:String, data:[String:AnyObject]?, completion:((success:Bool, encodedURLString:String, error:NSError?)->Void?) Parameters Description title Name of event. data Optiona [String:AnyObject] dictionary where values are either of type String or [String]. completion Optional completion block. // SAMPLE // Basic track call tealium.track(title: "someEvent", data: nil, completion: nil) // With optional data let optionalData = ["someKey": "someValue"] tealium.track(title: "someEventWithCustomData", data: optionalData, completion: nil) // With optional callback tealium.track(title: "someEventWithCallback", data: nil, completion: { (success: Bool, encodedURLString: String, error: NSError?) in // Any follow up code here })   TRACK ENCODED URL STRING This alternate track call is intended for retrying calls initially attempted by the above track(title:data:completion:) method.  EncodedURLStrings from that method's completion handler can be store and the exact same dispatch may be attempted later using this method. tealium.track(encodedURLString:String, completion:((success:Bool, encodedURLString:String, error:NSError?)->Void)?) Parameters Description title Name of event. data Optiona [String:AnyObject] dictionary where values are either of type String or [String]. completion Optional completion block. // SAMPLE // Example retrieval - not actual library function guard let urlString = somePersistentDispatchStore().firstObject as? String else { return } // Basic track tealium.track(encodedURLString: urlString, completion: nil) // With optional callback tealium.track(encodedURLString: urlString, completion: { (success: Bool, encodedURLString: String, error: NSError?) in // Example queuing - not actual library function somePersistentDispatchStore().saveToLastPosition(encodedURLString) }) ... View more

To integrate the Tealium Swift Library:   Add to Project Initialize Track Events Additional Info 0. Requirements   - Swift 2+   1. Add to Project:   Import the Tealium folder into your project. The library is made up of the following .swift files:   Tealium TealiumCollect TealiumConfig TealiumConstants TealiumDataManager TealiumIOManager TealiumLogger Note: The above classes with links are those with public APIs.   2. Initialize: To initialize, first create a TealiumConfig object with the account requirements, then pass the configuration object as an argument to the Tealium initializer.  See the API documentation for additional config options:   // Minimum setup var config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "dev_qa_or_prod") Tealium tealium = Tealium(config: config)   3. Track events:   Track any events that occur in the app such as button clicks or lifecycle.   // Basic track call tealium.track("someUniqueTitle", nil, nil); // With optional data let data = [ "someKey" : "someValue" ] tealium.track("someUniqueTitle", data, nil); // With optional callback tealium.track("someUniqueTitle", data: null) { (success, encodedURLString, error) in // Any monitoring or follow-up code here }   4. Additional Info   Githhub Repo API Videos ... View more

FUNCTION NAME DESCRIPTION addPersistentData(data : [String : AnyObject]) Add data to save with the library's persistent store. deletePersistentData(keys : [String]) Remove saved data from the library's persistent store. getPersistentData() Retrieve the existing persistent data as [String:AnyObject] addVolatileData(data : [String : AnyObject]) Add data to all dispatches for this session only. deleteVolatileData(keys : [String]) Remove data from the volatile data store. getVolatileData() Retrieve the existing volatile data as [String:AnyObject] getSessionId() Get the current session id string resetSessionId() Reset the session id string    ADD PERSISTENT DATA Make data available through multiple app sessions. addPersistentData(data:[String:AnyObject]) Parameters Description Example Value dictionary Required dictionary to add. Values should be of type String or [String] only. ["key":"value"] // SAMPLE let customData = ["someKey":"someValue"] tealium.getDataManager().addPersistentData(data:customData);   DELETE PERSISTENT DATA deletePersistentData(keys:[String]) Parameters Description Example Value Array Required array of Keys as strings ["key1", "key2"] // SAMPLE let keysToDelete = ["keyA", "keyB"] tealium.getDataManager().deletePersistentData(keys:keysToDelete);   GET PERSISTENT DATA getPersistentData() Returns Description Example Value Dictionary A [String:AnyObject] dictionary ["key1", "key2"] // SAMPLE let data : [String, AnyObject] = tealium.getDataManager().getPersistentData()   ADD VOLATILE DATA Make data available to all calls for active session only. addVolatileData(data:[String:AnyObject]) Parameters Description Example Value dictionary Required dictionary to add. Values should be of type String or [String] only. ["key":"value"] // SAMPLE let customData = ["someKey":"someValue"] tealium.getDataManager().addVolatileData(data:customData);   DELETE VOLATILE DATA deleteVolatileData(keys:[String]) Parameters Description Example Value Array Required array of Keys as strings ["key1", "key2"] //SAMPLE let keysToDelete = ["keyA", "keyB"] tealium.getDataManager().deleteVolatileData(keys:keysToDelete);   GET VOLATILE DATA getVolatileData() Returns Description Example Value Dictionary A [String:AnyObject] dictionary ["key1", "key2"] // SAMPLE let data : [String, AnyObject] = tealium.getDataManager().getVolatileData()   GET SESSION ID getSessionId() Returns Description Example Value String String representation of a timestamp in milliseconds "1473371215123" // SAMPLE let sessionId = tealium.getDataManager().getSessionId()   RESET SESSION ID Used to manually reset session id if needing to identify a new session other than at app start time. resetSessionId() Returns Description Example Value String New String representation of a timestamp in milliseconds that will be added to all dispatches for the remainder of the current session. The returned String is for monitoring convenience as it is automatically added to the volatile data store when this method is called. "1473371215123" // SAMPLE tealium.getDataManager().resetSessionId()    ... View more

The following are the public Tealium classes with public APIs:   Tealium TealiumConfig TealiumDataManager ... View more

To integrate the Tealium-Windows Library: Build .dll Add to Project Initialize Track Events Run Simulator Sideload Device Additional Info Version History 0. Requirements Windows 10+ Visual Studio Community 2015+ Tealium AudienceStream account (consult your Tealium Account manager) 1. Build the Tealium .dll: a. Open the TealiumUWP folder: TealiumUWP.sln. b. Build the solution:                               2. Add to a Universal App Project: a. Add Reference: TealiumUWP.dll:                                b. Change Property: Copy Local: to False for the TealiumUWP dll reference and the TealiumUWP dll refere in your app project:                                  3. Initialize: a. In the Project's App.xaml.css file:  add import header: using TealiumUWP:                                b. Initialize the singleton: // Sample Tealium.Initialize("yourAccount", "yourProfile", "dev_qa_or_prod", TealiumLogLevel.DEBUG) 4. Track Events: Track any events that occur in the app such as button clicks or lifecycle. // Basic track call Tealium.Track("event_name"); // With optional data Dictionary<string, string> data = new Dictionary<string, string>(); data.Add("someStringKey", "someStringValue_or_stringifiedArrayOfStrings"); Tealium.Track("event_name_with_data", data) // With callback function pointer public void someFunctionToCallBack(bool c){ // ... code here } Tealium.Track("event_name_with_callback", data, someFunctionToCallBack)   5. Running Simulator a. Set application to build and deploy: b. Compile and run:                                6. Sideload onto a Device a. Resolve any certificate requirements: Double-click Package.appxmanifest Select 'Packaging' tab Click on 'Choose Certificate' Select the 'Configure Certificate' drop-down Select 'Create test certificate' (or other valid certificate) Create password if needed Click 'OK' b. Create App Package: Right-click Project: Store: Create App Package. Select 'No' to upload to Windows store. Make sure 'Generate app bundle:" is set to 'Always' Click 'Create' Note location of output folder   c. Load onto device: In a browser, navigate to: http://<device_ip>/AppManager.htm Select 'Apps' +Install app: App Package: select the .appsxsymbundle +Install app: Dependency: add a dependency for each dependency file in the Dependency folder Select Deploy: Go to load the app on to the device 7. Additional Info Githhub Repo API 5. Version History: 1.0.0 (current) ... View more

FUNCTION NAME DESCRIPTION initialize(account, profile, environment, logLevel) Initializer for Tealium Environment. resetSesionId() Optionally reset the session id. Track(title, dictionary, optionalCallBack) Track event for immediate dispatch, with optional dictionary and optional callback function. SetSessionId (sessionId) Optionally set user defined session id. SetVisitorId (visitorId) Optionally set user defined visitor id.   INITIALIZE initialize(string account, string profile, string environment, LogLevel logLevel) Parameters Description Example Value account Tealium account name tealiummobile profile Tealium profile demo environment Tealium environment (usually dev/qa/prod) dev  logLevel Desired log level: 0-Trace, 1-DEBUG, 2-INFO, 3-WARN, 4-ERROR, 5-FATAL LogLevel.Error // SAMPLE Tealium.Initialize("tealiummobile", "demo", "dev", TealiumLogLevel.DEBUG);   RESET SESSION ID ResetSessionId() // SAMPLE Tealium.ResetSessionId()   TRACK  Track(string title, Dictionary <string, string> data, Action<Bool> callBackFunction) Parameters Description title Name of event (becomes value for tealium_event) data Optional dictionary of additional data. callBackFunction Function type parameter that executes after returning from Track function. // SAMPLE // Basic track call String name = "button pressed"; Tealium.Track(name); // With optional data Dictionary <string, string> data = new Dictionary<string, string> (); data.Add("Key","Value"); name = "button pressed with optional data" Tealium.Track(name, data); // With optional callback public void callBackFunction(){ // ... Custom code here } name = "button pressed with optional callBack" Tealium.Track(name, callBackFunction) // With optional data and callback name = "button pressed with optional data and callback" Tealium.Track(name, data, callBackFunction)   SET SESSION ID SetSessionId(string sessionId) Parameters Description sessionId String identifier for a session (app launch to terminate). // SAMPLE String sessionId = "123456789123" Tealium.SetSessionId(sessionId);      SET VISITOR ID SetVisitorId(string visitorId) Parameters Description visitorId String identifier for a visitor id. // SAMPLE String visitorId = "312048730c8c11e6b4cbacbc329f41c7"; Tealium.SetVisitorId(visitorId);   ... View more

This guide shows how to add Tealium to your Java application to track event activity.  Before you begin, here's a video introduction to the platform: Table of Contents Placeholder Installation Requirements  Before proceeding, ensure you have satisfied the following requirements: Tealium account enabled for AudienceStream, DataAccess, or EventStream. Java IDE eg. Eclipse Java 7 or higher Get the Code The code for the Tealium Java library is stored in Github. You must retrieve the code to get started. Download: Tealium for Java We recommend cloning the library (instead of downloading) to make it easier to update to future releases. Code Setup Import all of the .java files from the src/main/java/com/tealium directory, then add this code: import com.tealium.* Using Maven Make the following changes to your pom.xml file: Add the repository: <repository> <id>maven-tealium</id> <url>http://maven.tealiumiq.com/java/releases/</url> </repository> Add the dependency: <groupId>com.tealium</groupId> <artifactId>java</artifactId> <version>1.3.0</version> Initialization Once the files are added to your project you are ready to start coding. The Tealium instance must be invoked with the following parameters before you can begin tracking: account - the name of your account profile - the name of the profile within your account environment - (optional) one of "qa" or "prod" datasource - (optional) the data source key from your Universal Data Hub account Tealium tealium = new Tealium.Builder("ACCOUNT", "PROFILE") .setEnvironment("prod") .setDatasource("DATASOURCE") .build(); Tracking Once the Tealium instance has been defined you can begin tracking events with the method track() , which takes the following parameters: eventName (required) - a name to identify the event eventData (optional) - an object with event attributes as key/value pairs callback (optional) - a function to be called when the track() method completes   // Set event attributes Udo data = new Udo(); data.put("user_id", "0123456789"); data.put("email_address", "user@example.com"); // With optional callback DispatchCallBack callBack = new DispatchCallBack(){ public void dispatchComplete(boolean success, String encodedURLString, String error){ // Callback handling System.out.println("Dispatch successful: " + String.valueOf(success)); } } // Tracking a login event tealium.track("user_login", data, callBack); Watch this video for a quick summary of the installation steps:   Function Definitions   Tealium.Builder() Instantiate a Tealium object. Tealium.Builder(account, profile, environment).build() Parameters Type Description Example Value account String Tealium account name "companyxyz" profile String Tealium profile "main"  environment  String Tealium environment identifer "prod" datasource String Tealium data source key from UDH "abc123" // Init Tealium Tealium teal = new Tealium.Builder('ACCOUNT', 'PROFILE') .setEnvironment("ENVIRONMENT") .setDatasource("DATASOURCE") .build(); track() Convenience track call. track(eventName) Parameters Type Description eventName String Name of event (becomes the tealium_event and  event_name event attribute values) tealium.track("page_view");   Convenience track call for events that can optionally include additional data and a callback. track(event, eventData, [callback]) Parameters Type Description eventName String Name of event (becomes the tealium_event and  event_name event attribute values) eventData Udo (Optional) Udo of additional data source keys and values optional_callback Function (Optional) Object conforming to the Tealium call back interface // Event attributes Udo data = new Udo(); data.put("user_id", "0123456789"); data.put("email_address", "user@example.com"); // With optional callback DispatchCallBack callBack = new DispatchCallBack(){ public void dispatchComplete(boolean success, String error) { // Callback code here } } tealium.track("user_login", data, callback);   getDataManager() Fetch the DataManager object. The Data Manager processes call time data and handles persistent data. getDataManager() Returns Description Example Value DataManager Instance of the Tealium Data Manager object NA DataManager dm = tealium.getDataManager() addPersistentData() Use the DataManager to make data available across multiple app sessions. addPersistentData(map<String, Object>) Parameters Description Example Value data Required map to add to the existing persistent udo ["key":"value"] Udo data = new Udo(); data.put("aKey", "aValue") tealium.getDataManager().addPersistentData(data);  deletePersistentData() Use the DataManager to delete previously persisted data by providing a list of keys to delete. deletePersistentData(array<String>) Parameters Description Example Value keys Array of Keys as strings ["key1", "key2"] List<String> list = new List<>(); list.append("key_to_delete"); tealium.getDataManager().deletePersistentData(list); getPersistentData() Use the DataManager to retrieve data that has been persisted. getPersistentData() Returns Description Example Value Udo Udo of persistent data ["key1", "key2"] Udo persistentData = tealium.getDataManager().getPersistentData() getSessionId() Use the DataManager to fetch the current session ID. A session ID is created on initialization of the Tealium object. getSessionId() Returns Description Example Value String String representation of a timestamp in milliseconds "1473371215123" tealium.getDataManager().getSessionId()  resetSessionId() Use the DataManager to reset the session ID. For use when needing to start a new session other than at app start time. resetSessionId() Returns Description Example Value String New String representation of a timestamp in milliseconds that will be added to all dispatches for the remainder of the current session. The returned String is for monitoring convenience as it is automatically added to the volatile data store when this method is called. "1473371215123" tealium.getDataManager().resetSessionId()    ChangeLog The type signatures of some of the methods have changed. Event data used to be a Map<String, Object> type, but has changed to be a Udo (universal data object) type. Event data must follow a specific format where each value is either a String or List<String> , so a more specific type is helpful. (See the Universal Data Object Guide for the formatting details.) The new Udo type implements the Map<String, Object> interface, and therefore can be used wherever a Map<String, Object> can. Although still usable, the previous methods using Map<String, Object> have been deprecated and should be switched out for the updated version since they will likely be dropped in a future update.   1.1.0 - Current 1.0.0 - 1.0.1 ... View more

NOTE: This article is deprecated. Please see: https://community.tealiumiq.com/t5/Swift/tkb-p/swift This guide shows how to add Tealium to your Swift app to track user activity. Before you begin, here's a video introduction to the platform: Table of Contents Placeholder Requirements Tealium account enabled for AudienceStream, DataAccess, or EventStream Swift 3.0+ Xcode 8.0+  Add the Dependency The code for the Tealium Swift library can be easily installed using Carthage or downloaded from on Github. The repository contains the following modules: Core (tealium/core)- (required) The main module. AppData (tealium/appdata) - Adds event attributes  device_uuid and tealium_vid to tracked data (required for AudienceStream visitor stitching). Attribution (tealium/attribution) - Adds event attribute device_advertising_id  (identifierForVendor) to tracked data. Please note that using this module requires an additional app store submission step. Collect (tealium/collect) - (highly recommended) Used to activate tracking calls to Tealium Collect. TagManagement (tealium/tagmanagement) - (highly recommended for Tealium iQ users) Used to implement JavaScript-based tracking tags in Swift apps. Logger (tealium/logger) - Enables logging of warnings, errors, and other helpful messages. PersistentData (tealium/persistentdata) - Enables the ability to add persistent data to tracking calls. VolatileData (tealium/volatiledata) - Enables the ability to add persistent session data to tracking calls. Using Carthage Carthage is a simple way to manage dependencies in Swift. Install Carthage manually or via Homebrew with the following terminal command: brew install carthage Then add the following entry to the Cartfile in your project: github "tealium/tealium-swift" Then update from the terminal with: carthage update This will produce frameworks for the following platforms: iOS macOS tvOS watchOS  To build only for a particular platform, use Carthage's --platform argument: carthage update --platform ios   The Carthage built frameworks do not include the Attribution module by default. Manually The code for the Tealium Swift library is stored on Github. You must download and install the library. Download: Tealium for Swift Import the Tealium folder into your project and add the desired modules. The library employs a drag-and-drop modular architecture when the source files are referenced directly. Each subfolder within tealium-swift/tealium contains all the files related to that module.  The Core submodule is required and the Collect submodule is highly recommended. To disable a previously added module, either remove it from the project or manually edit the module file and change the method moduleConfig() to return false. Watch this video for an overview of the installation and setup of the code: Initialization The Tealium instance must be configured with the following parameters: account - the name of your iQ account profile - the name of the mobile profile within your iQ account environment - one of "qa", or "prod" datasource - (optional) data source key from UDH // Minimum setup var config = TealiumConfig(account: "your_account", profile: "your_profile", environment: "prod") let tealium = Tealium(config: config) // With Datasource module (default included with framework builds) var configWithDatasource = TealiumConfig(account: "your_account", profile: "your_profile", environment: "prod", datasource: "abc123") let tealiumWithDatasource = Tealium(config: configWithDatasource) Tracking All tracking is done with the track() method, which takes the following parameters: title - (required) the name of the screen view or event to be tracked data - a dictionary object of tracking data type - the type of tracking call, as defined by the TealiumTrackType constants:   TealiumTrackType.view - for tracking screen views   TealiumTrackType.activity - (default) for tracking non-view user events completion - a closure to be run upon completion of the tracking call The Collect submodule must be added to enable tracking calls.   // Basic track call tealium.track(title:"someEvent", data:nil, completion:nil); // With optional data let data = [ "someKey" : "someValue" ] tealium.track(title:"someEvent", data:data, completion:nil); // With optional callback tealium.track(title:"someEvent", data: null, completion: { (success, info, error) in // Any monitoring or follow-up code here }) // Specifying track type - ie appearance of a UIView tealium.track(type:TealiumTrackType.view, title: "screenView", data: nil, completion: nil)  Change Log 1.1 (current) 1.0.0-1.0.1   ... View more

The following document applies to all Tealium Internet-of-Things (IoT) and Over-the-Top (OTT) platform supported libraries (SDKs):   Why only Cloud Delivery support IoT & OTT Libraries   Requirements - Cloud Delivery enabled account - Relevant device developer access     1. Why Only Cloud Delivery supported:   Tealium IQ requires a browser, webkit object, or combination of processes that can handle HTTP calls and JavaScript processing.  Many IoT and OTT devices currently on the market do not have the capability to process the JS component without substantial burden being placed on these devices.    Not all IoT devices can process JavaScript but all can make HTTP calls, so only Collect SDKs will be made at this time.   See Tealium's Collect vdata endpoint for reference.   2. Tealium IoT & OTT Libraries: Python Roku   ... View more

This article describes how to configure the Adobe AppMeasurement for JS tag for a native mobile implementation. In this article: Table of Contents Placeholder Prerequisites Mobile Profile in Tealium iQ Tag Management For additional information, see Creating a Mobile Profile. Tag Configuration and Data Mapping Go to the Tag Marketplace and add the Adobe Analytics AppMeasurement for JS tag (learn more about how to add a tag), the configure the following settings: Set Device Type to Mobile App. Configure the other settings according to the AppMeasurement for iQ guide. Click on Data Mappings and add the following mappings: Tealium Variable AppMeasurement Variable screen_title pageName uuid measure.vistorID timestamp ts app_id contextData.a.AppID lifecycle_diddetectcrash contextData.a.CrashEvent lifecycle_isfirstwaketoday contextData.a.DailyEngUserEvent lifecycle_dayofweek_local contextData.a.DayOfWeek lifecycle_dayssincelaunch contextData.a.DaysSinceFirstUse lifecycle_dayssincelastwake contextData.a.DaysSinceLastUse lifecycle_priorsecondsawake contextData.a.PreviousSessionLength device_resolution contextData.a.Resolution carrier contextData.a.CarrierName lifecycle_isfirstlaunchupdate contextData.a.UpgradeEvent device contextData.a.DeviceName lifecycle_hourofday_local contextData.a.HourOfDay lifecycle_firstlaunchdate_MMDDYYYY contextData.a.InstallDate lifecycle_isfirstlaunch contextData.a.InstallEvent lifecycle_totalwakecount contextData.a.Launches lifecycle_launchcount_update contextData.a.LaunchesSinceUpgrade lifecycle_dayssinceupdate contextData.a.DaysSinceUpgrade lifecycle_type contextData.a.LaunchEvent lifecycle_isfirstwakemonth contextData.a.MonthlyEngUserEvent platform_version contextData.a.OSVersion platform contextData.a.OSEnvironment Custom Context Data To map custom context data use this format with Adobe's reserved namespace ".a" for mobile analytics: contextData.a.myvar . For example, to map a variable named customer_email , the mapping destination would be "contextData.a.customer_email". Learn more about context data and mobile analytics from Adobe. Additional Resources To take advantage of the lifecycle tracking event, use one of the Tealium Lifecycle Tracking Modules: Lifecycle Module - iOS Lifecycle Module - Android ... View more

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

Requirements Overview Enabling a Profile for Mobile Adding Tags for Mobile Requirements A Tealium mobile library installed in your app that references your Tealium iQ profile Overview Enabling a Profile for Mobile Adding Tags Enabling a Profile for Mobile In order to connect your mobile app to Tealium's systems, you need to enable the Tealium iQ profile for mobile. To enable a profile: 1. In Tealium iQ click on the Save/Publish button. 2. From the Save/Publish modal, click the Configure Publish Settings button.     3. From the Publish Configuration modal, click the Mobile Library Publishing tab. 4. Click the Activate Mobile Library button then click Save. Mobile SDK v4.1 applies to all Android & iOS Libraries of version 4.1 and above. Mobile SDK v5.0 applies to all 5.x Android & iOS Libraries.       Note: By default, Tag Management is set to 'Off' and Tealium Collect is set to 'On.' If you will be configuring and using tags in Tealium iQ, you will want to switch Tag Management to 'On.' If you will not be using our Cloud Based Delivery solution for mobile (requires an AudienceStream account), you will want to switch Tealium Collect to 'Off.' For more information on your individual account services, please contact your account manager. There are numerous settings that affect how your mobile implementation works. For more information on these, see our Mobile Publish Settings article. 5. Save/Publish your Tealium iQ profile Just like other Tealium implementations, you'll need to tell our system what data variables to pass (or map) to your target vendors. The mobile libraries come with pre-built functions that automatically provide a number of these standard data variables. When you enable a Tealium iQ profile to use the mobile libraries, these data variables are automatically added for you. Navigate to the Data Layer tab to see the new mobile-specific data variables that are now available for use.   Adding Tags for Mobile Adding tags to mobile profiles works the same as for a non-mobile profile. However, only Tags that perform data collection are supported within mobile profiles. Tags that push information to a page (such as an ad serving tag) or that require direct interaction with the native app will not yet work within an iQ mobile profile. If you add the Tealium Collect Tag to your mobile profile you can take advantage of AudienceStream Live Events to verify that your app is sending data correctly. ... View more

This guide shows how to add Tealium to your Python application to track activity in the Universal Data Hub. Table of Contents Placeholder Getting Started Requirements Tealium account enabled for AudienceStream, DataAccess, or EventStream Python 2.7+  Installation  The Tealium for Python package can be installed using pip. If you haven't used pip before please read the pip installation guide. Using Python 2: pip install tealium Using Python 3: pip3 install tealium Initialization Once the Tealium for Python package is installed you are ready to start coding. Use the following code to import the Tealium module and initialize with the following parameters: account - the name of your account profile - the name of the profile within your account environment - (optional) one of "qa", or "prod" path - (optional) path to save persisted data datasource - (optional) the data source key from UDH It may be necessary to use named parameters when omitting optional parameters from the call, e.g. "datasource" must be named if omitting "path". from tealium import Tealium teal = Tealium('account', 'profile', 'environment', datasource:'datasource') Tracking Once the Tealium object has been defined you can begin tracking events with the method trackEvent() , which takes the following parameters: event (required) - a name to identify the event data - optional dictionary with event data as key/value pairs callback - optional callback function A function that triggers or responds to an event trigger could look like the following:   def tealiumCallback(info, success, error=None): if error is not None: print (info, success, error) return print (info, success) eventData = {'someKey': 'someValue'} teal.trackEvent('someEvent', data:eventData, callback:tealiumCallback)  Additional Resources Sample Python Script Function Definitions Tealium() Creates a Tealium object that will be used to track events. Tealium(account, profile, environment, path, datasource) Parameters Type Description account String Tealium account name eg. "companyXYZ" profile String Tealium profile name eg. "main" environment (optional) String Tealium environment identifer eg. "prod" path (optional) String Where to save persistent data eg. "/path/to/persist/data" datasource (optional) String The data source key from UDH eg. "abc123" trackEvent() Creates a Tealium object that will be used to track events. trackEvent(eventName, data, callback) Parameters Type Description eventName String Name of the event eg. "user_login" data Dictionary Dictionary of additional data source keys and values (optional) callback Function Optional callback function resetSessionId() Reset the session ID. For use when needing to start a new session other than at app start time. resetSessionId() Returns Description Example Value String A timestamp in milliseconds, converted to a String, that is associated with all subsequent tracking. The session ID is maintained internally and automatically included as the tealium_vid event attribute. "1473371215123" ... View more

This tutorial shows how to set up Charles to proxy HTTP traffic in and out of your iOS device. This is especially helpful when verifying proper configurations of the Tealium iOS library. This article covers an older version of Charles. For newer versions of Charles read Setting up Charles 3.10 to Proxy your iOS Device. Configuring Charles On your computer: Go to Proxy: Proxy Settings... On the Proxies tab: Enter "8888" in the HTTP Proxy Port field On the SSL tab click the checkbox for Enable SSL Proxying Go to System Preferences > Network > Wi-Fi > Advanced > TCP/IP and make note of the IPV4 Address (i.e. 10.0.1.101) Configure Your iOS Device Go to http://charlesproxy.com/charles.crt from your device and download Charles SSL certificate Okay the certificate as trusted (be sure to disable or remove it once you're done) Go to the Settings App: Wifi: Select the detailed disclosure button (round blue button with the white arrow) for your network Under HTTP Proxy, select "Manual" Enter in the address from step (dev machine 1.) into the Server field, and the port number from step (charles 2.) ​​ Restart Charles Run Safari on your iOS device to test. This should prompt Charles to display a dialog box to allow or deny SSL proxying. Allow the proxying. Read more about SSL Proxying with Charles. Additional Resources Setting up Charles to Proxy your Android Device Charles: SSL connectors from within iPhone applications   ... View more